diff --git a/apps/api/autumn.config.ts b/apps/api/autumn.config.ts index ea627c0269..36b8081126 100644 --- a/apps/api/autumn.config.ts +++ b/apps/api/autumn.config.ts @@ -3,6 +3,7 @@ import { AI_CREDITS_FEATURE_ID, AI_CREDITS_MARKUP_PERCENT, BILLING_SUB_ORGS_FEATURE_ID, + ENTERPRISE_SSO_FEATURE_ID, OPENROUTER_BYOK_ADDON_ID, OPENROUTER_BYOK_FEATURE_ID, UPTIME_MONITORS_FEATURE_ID, @@ -112,6 +113,13 @@ export const billingSubOrgs = feature({ type: "boolean", }) +// SSO (SAML/OIDC) and SCIM provisioning. Enterprise is sales-led: granted per customer in Autumn. +export const enterpriseSso = feature({ + id: ENTERPRISE_SSO_FEATURE_ID, + name: "Enterprise SSO and SCIM", + type: "boolean", +}) + export const startup = plan({ id: "startup", name: "Startup", diff --git a/apps/api/src/routes/internal/enterprise-sso.http.test.ts b/apps/api/src/routes/internal/enterprise-sso.http.test.ts new file mode 100644 index 0000000000..e92d6199f5 --- /dev/null +++ b/apps/api/src/routes/internal/enterprise-sso.http.test.ts @@ -0,0 +1,176 @@ +import { afterEach, describe, expect, it } from "@effect/vitest" +import { + ApiSchemaErrors, + ApiUnexpectedErrors, + CurrentTenant, + EnterpriseSsoApiGroup, + EnterpriseSsoDocument, + EnterpriseSsoUnavailableError, + OrgId, + RoleName, + ScimTokenIssued, + UserId, +} from "@maple/domain/http" +import { Array as Arr, Context, Effect, Layer, Schema } from "effect" +import { HttpRouter } from "effect/http" +import { HttpApi, HttpApiBuilder } from "effect/http-api" +import { ApiErrorBoundaryLive } from "@maple/backend/http/error-boundary" +import { AuditLogService, type AuditLogRecordInput } from "@maple/backend/services/audit/AuditLogService" +import { + EnterpriseSsoService, + type EnterpriseSsoServiceApi, +} from "@maple/backend/services/org/enterprise-sso/EnterpriseSsoService" +import { HttpEnterpriseSsoLive } from "./enterprise-sso.http" + +class SsoOnlyApi extends HttpApi.make("MapleInternalApi") + .add(EnterpriseSsoApiGroup) + .middleware(ApiSchemaErrors) + .middleware(ApiUnexpectedErrors) {} + +const ORG_ID = Schema.decodeSync(OrgId)("org_sso_route") +const USER_ID = Schema.decodeSync(UserId)("user_sso_route") +const SCIM_TOKEN = "scim_secret_value_shown_once" +const CLIENT_SECRET = "oidc-client-secret-value" + +const document = new EnterpriseSsoDocument({ + entitled: true, + domains: [], + connection: null, + directory: null, + roleMappings: [], + groups: [], + bypassUsers: [], +}) + +const handlers: Array<() => void> = [] +afterEach(() => { + for (const dispose of handlers.splice(0)) dispose() +}) + +/** Every service method answers the empty document and records its name. */ +const recordingService = (calls: Array) => { + const ok = (name: string) => () => Effect.sync(() => (calls.push(name), document)) + const issued = (name: string) => () => + Effect.sync(() => (calls.push(name), new ScimTokenIssued({ document, token: SCIM_TOKEN }))) + const api: EnterpriseSsoServiceApi = { + get: ok("get"), + addDomain: ok("addDomain"), + verifyDomain: ok("verifyDomain"), + removeDomain: ok("removeDomain"), + createConnection: ok("createConnection"), + updateConnection: ok("updateConnection"), + setEnforcement: ok("setEnforcement"), + deleteConnection: ok("deleteConnection"), + createDirectory: issued("createDirectory"), + rotateDirectoryToken: issued("rotateDirectoryToken"), + setDirectoryState: ok("setDirectoryState"), + deleteDirectory: ok("deleteDirectory"), + setRoleMappings: ok("setRoleMappings"), + addBypassUser: ok("addBypassUser"), + removeBypassUser: ok("removeBypassUser"), + applyDirectoryGroup: () => Effect.fail(new EnterpriseSsoUnavailableError({ message: "unused" })), + confirmDeprovisioned: () => Effect.succeed(true), + } + return Layer.succeed(EnterpriseSsoService, api) +} + +const makeHarness = (role: string) => { + const calls: Array = [] + const audited: Array> = [] + const audit = Layer.succeed(AuditLogService, { + record: (input) => + Effect.sync(() => void audited.push({ action: input.action, metadata: input.metadata })), + list: () => Effect.die("unused"), + }) + const authorization = Layer.succeed( + CurrentTenant.SessionAuthorization, + CurrentTenant.SessionAuthorization.of({ + bearer: (httpEffect) => + Effect.provideService( + httpEffect, + CurrentTenant.Context, + new CurrentTenant.TenantSchema({ + orgId: ORG_ID, + userId: USER_ID, + roles: [Schema.decodeSync(RoleName)(role)], + authMode: "clerk", + }), + ), + }), + ) + const routes = HttpApiBuilder.layer(SsoOnlyApi).pipe( + Layer.provide(HttpEnterpriseSsoLive), + Layer.provide(ApiErrorBoundaryLive), + Layer.provideMerge(authorization), + Layer.provide(Layer.mergeAll(recordingService(calls), audit)), + ) + const { handler, dispose } = HttpRouter.toWebHandler(routes, { disableLogger: true }) + handlers.push(() => void dispose()) + + const send = async (method: string, path: string, body?: unknown) => { + const response = await handler( + new Request(`http://maple.test/internal/enterprise-sso${path}`, { + method, + headers: { authorization: "Bearer test-token", "content-type": "application/json" }, + body: body === undefined ? null : JSON.stringify(body), + }), + Context.empty() as never, + ) + return { status: response.status, text: await response.text() } + } + return { send, calls, audited } +} + +describe("/internal/enterprise-sso", () => { + it("lets a member read, but refuses every write before it reaches the service or the audit log", async () => { + const harness = makeHarness("org:member") + expect((await harness.send("GET", "/")).status).toBe(200) + const writes = [ + ["POST", "/domains", { domain: "acme.com" }], + ["PUT", "/connection/enforcement", { enforced: false }], + ["POST", "/directory"], + ["DELETE", "/directory"], + ["PUT", "/directory/role-mappings", { mappings: [] }], + ] as const + for (const [method, path, body] of writes) { + const response = await harness.send(method, path, body) + expect(response.status, `${method} ${path}`).toBe(403) + } + expect(harness.calls).toEqual(["get"]) + expect(harness.audited).toEqual([]) + }) + + it("audits each admin write by action, and never with a secret in it", async () => { + const harness = makeHarness("org:admin") + expect((await harness.send("POST", "/domains", { domain: "acme.com" })).status).toBe(200) + const connection = await harness.send("POST", "/connection", { + name: "Acme", + provider: "oidc_custom", + domains: ["acme.com"], + oidc: { + discoveryUrl: "https://id.acme.com/.well-known/openid-configuration", + clientId: "maple", + clientSecret: CLIENT_SECRET, + }, + }) + expect(connection.status).toBe(200) + expect((await harness.send("PUT", "/connection/enforcement", { enforced: true })).status).toBe(200) + const created = await harness.send("POST", "/directory") + expect(created.status).toBe(200) + // The token goes back to the admin exactly once, in this response. + expect(created.text).toContain(SCIM_TOKEN) + expect((await harness.send("POST", "/directory/token")).status).toBe(200) + + expect(Arr.map(harness.audited, (entry) => entry.action)).toEqual([ + "enterprise_sso.domain_added", + "enterprise_sso.connection_created", + "enterprise_sso.connection_enforced", + "enterprise_sso.directory_created", + "enterprise_sso.directory_key_rotated", + ]) + const trail = JSON.stringify(harness.audited) + expect(trail).not.toContain(SCIM_TOKEN) + expect(trail).not.toContain(CLIENT_SECRET) + expect(harness.audited[0]?.metadata).toEqual({ domain: "acme.com" }) + }) +}) diff --git a/apps/api/src/routes/internal/enterprise-sso.http.ts b/apps/api/src/routes/internal/enterprise-sso.http.ts new file mode 100644 index 0000000000..f150ddc906 --- /dev/null +++ b/apps/api/src/routes/internal/enterprise-sso.http.ts @@ -0,0 +1,180 @@ +import { HttpApiBuilder } from "effect/http-api" +import { CurrentTenant, EnterpriseSsoForbiddenError, MapleInternalApi } from "@maple/domain/http" +import { Array as Arr, Effect } from "effect" +import * as Policy from "@maple/domain/policy" +import { recordHttpAudit } from "@maple/backend/services/audit/AuditLogService" +import { + EnterpriseSsoService, + normalizeDomain, +} from "@maple/backend/services/org/enterprise-sso/EnterpriseSsoService" + +const requireSsoAdmin = Effect.gen(function* () { + const tenant = yield* CurrentTenant.Context + yield* Policy.check( + tenant.roles, + "sso:manage", + (denial) => new EnterpriseSsoForbiddenError({ message: denial.message }), + ) + return tenant +}) + +// Reads are open to every member (the page says who to ask); every write is admin-only and audited. +// Audit metadata names what changed, never a secret: no client secret, certificate or SCIM token. +export const HttpEnterpriseSsoLive = HttpApiBuilder.group(MapleInternalApi, "enterpriseSso", (handlers) => + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + + return handlers + .handle("get", () => + CurrentTenant.Context.pipe( + Effect.flatMap((tenant) => sso.get(tenant.orgId)), + Effect.withSpan("HttpEnterpriseSso.get"), + ), + ) + .handle("addDomain", ({ payload }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.addDomain(tenant.orgId, tenant.userId, payload.domain) + yield* recordHttpAudit("enterprise_sso.domain_added", { + metadata: { domain: normalizeDomain(payload.domain) }, + }) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.addDomain")), + ) + .handle("verifyDomain", ({ params }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.verifyDomain(tenant.orgId, params.domain) + yield* recordHttpAudit("enterprise_sso.domain_verified", { + metadata: { domain: normalizeDomain(params.domain) }, + }) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.verifyDomain")), + ) + .handle("removeDomain", ({ params }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.removeDomain(tenant.orgId, params.domain) + yield* recordHttpAudit("enterprise_sso.domain_removed", { + metadata: { domain: normalizeDomain(params.domain) }, + }) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.removeDomain")), + ) + .handle("createConnection", ({ payload }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.createConnection(tenant.orgId, tenant.userId, payload) + yield* recordHttpAudit("enterprise_sso.connection_created", { + metadata: { + provider: payload.provider, + name: payload.name, + domains: Arr.join(Arr.map(payload.domains, normalizeDomain), ","), + }, + }) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.createConnection")), + ) + .handle("updateConnection", ({ payload }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.updateConnection(tenant.orgId, payload) + yield* recordHttpAudit("enterprise_sso.connection_updated", { + metadata: { + name: payload.name, + domains: Arr.join(Arr.map(payload.domains, normalizeDomain), ","), + idpSettingsChanged: payload.saml !== undefined || payload.oidc !== undefined, + }, + }) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.updateConnection")), + ) + .handle("setEnforcement", ({ payload }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.setEnforcement(tenant.orgId, payload.enforced) + yield* recordHttpAudit( + payload.enforced + ? "enterprise_sso.connection_enforced" + : "enterprise_sso.connection_relaxed", + ) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.setEnforcement")), + ) + .handle("deleteConnection", () => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.deleteConnection(tenant.orgId) + yield* recordHttpAudit("enterprise_sso.connection_deleted") + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.deleteConnection")), + ) + .handle("createDirectory", () => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const issued = yield* sso.createDirectory(tenant.orgId) + yield* recordHttpAudit("enterprise_sso.directory_created") + return issued + }).pipe(Effect.withSpan("HttpEnterpriseSso.createDirectory")), + ) + .handle("rotateDirectoryToken", () => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const issued = yield* sso.rotateDirectoryToken(tenant.orgId) + yield* recordHttpAudit("enterprise_sso.directory_key_rotated") + return issued + }).pipe(Effect.withSpan("HttpEnterpriseSso.rotateDirectoryToken")), + ) + .handle("setDirectoryState", ({ payload }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.setDirectoryState(tenant.orgId, payload.paused) + yield* recordHttpAudit( + payload.paused + ? "enterprise_sso.directory_paused" + : "enterprise_sso.directory_resumed", + ) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.setDirectoryState")), + ) + .handle("deleteDirectory", () => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.deleteDirectory(tenant.orgId) + yield* recordHttpAudit("enterprise_sso.directory_deleted") + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.deleteDirectory")), + ) + .handle("setRoleMappings", ({ payload }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.setRoleMappings(tenant.orgId, payload.mappings) + yield* recordHttpAudit("enterprise_sso.role_mapping_updated", { + metadata: { + mappings: Arr.join( + Arr.map(payload.mappings, (m) => `${m.groupId}=${m.role}`), + ",", + ), + }, + }) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.setRoleMappings")), + ) + .handle("addBypassUser", ({ payload }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.addBypassUser(tenant.orgId, payload.userId) + yield* recordHttpAudit("enterprise_sso.bypass_added", { affectedUserId: payload.userId }) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.addBypassUser")), + ) + .handle("removeBypassUser", ({ params }) => + Effect.gen(function* () { + const tenant = yield* requireSsoAdmin + const document = yield* sso.removeBypassUser(tenant.orgId, params.userId) + yield* recordHttpAudit("enterprise_sso.bypass_removed", { affectedUserId: params.userId }) + return document + }).pipe(Effect.withSpan("HttpEnterpriseSso.removeBypassUser")), + ) + }), +) diff --git a/apps/api/src/routes/webhooks/clerk.http.ts b/apps/api/src/routes/webhooks/clerk.http.ts index 4eb9c7c1bd..d4894c6635 100644 --- a/apps/api/src/routes/webhooks/clerk.http.ts +++ b/apps/api/src/routes/webhooks/clerk.http.ts @@ -10,7 +10,10 @@ import { decodeClerkEnvelope, decodeClerkOrganizationMembership, decodeClerkUserCreated, + decodeClerkDirectoryGroup, decodeClerkUserDeleted, + decodeClerkUserUpdated, + isClerkDirectoryGroupEvent, isClerkMembershipEvent, membershipProductEvent, signupCompletedEvent, @@ -18,6 +21,7 @@ import { } from "@maple/backend/services/product-events/clerk-events" import { ProductEventsService } from "@maple/backend/services/product-events/ProductEventsService" import { AuditLogService } from "@maple/backend/services/audit/AuditLogService" +import { EnterpriseSsoService } from "@maple/backend/services/org/enterprise-sso/EnterpriseSsoService" import { receiveSvixWebhook, webhookText } from "./svix-receiver" /** @@ -35,6 +39,11 @@ import { receiveSvixWebhook, webhookText } from "./svix-receiver" * without it the membership cache and every user-bound credential keep * answering yes indefinitely. * + * - SCIM: `directoryGroup.*` keeps the org's IdP groups for the role mapping picker (home region + * only), and `user.updated` with `deprovisioned` runs the user sweep in every region. A member + * whose membership predates directory sync keeps it after deactivation, so this is what ends + * their keys. + * * Public route; authenticity is the Svix signature (`CLERK_WEBHOOK_SECRET`). * Any other event type is acknowledged with 200 so Clerk does not retry it. * @@ -56,6 +65,7 @@ const handler = Effect.gen(function* () { const revocation = yield* MembershipRevocationService const audit = yield* AuditLogService const regions = yield* OrganizationRegionService + const sso = yield* EnterpriseSsoService /** * A revocation that only half-ran is the state this whole handler exists to @@ -196,6 +206,63 @@ const handler = Effect.gen(function* () { if (isClerkMembershipEvent(envelope.value.type)) { return yield* handleMembership(envelope.value.data, envelope.value.type, envelope.value.timestamp) } + if (isClerkDirectoryGroupEvent(envelope.value.type)) { + const group = yield* decodeClerkDirectoryGroup(envelope.value.data).pipe(Effect.option) + if (Option.isNone(group)) { + yield* Effect.annotateCurrentSpan({ + "http.response.status_code": 400, + "maple.webhook.outcome": "parse_rejected", + }) + return webhookText("Unrecognized directory group payload", 400) + } + const outcome = yield* sso + .applyDirectoryGroup({ + directoryId: group.value.directory_id, + groupId: group.value.id, + displayName: group.value.display_name, + updatedAt: group.value.updated_at, + deleted: envelope.value.type === "directoryGroup.deleted", + }) + .pipe(Effect.option) + if (Option.isNone(outcome)) { + yield* Effect.annotateCurrentSpan({ + "http.response.status_code": 500, + "maple.webhook.outcome": "directory_group_failed", + }) + return webhookText("Directory group could not be saved", 500) + } + yield* Effect.annotateCurrentSpan({ + "http.response.status_code": 200, + "maple.webhook.outcome": outcome.value === "applied" ? "handled" : "not_home_region", + }) + return webhookText("ok", 200) + } + if (envelope.value.type === "user.updated") { + const user = yield* decodeClerkUserUpdated(envelope.value.data).pipe(Effect.option) + const userId = Option.flatMap(user, (u) => + u.deprovisioned === true ? decodeUserId(u.id) : Option.none(), + ) + if (Option.isSome(userId)) { + // Clerk sets this only once every directory managing the user has deprovisioned them, + // and then the user cannot sign in anywhere, so every org's credentials go too. + yield* Effect.annotateCurrentSpan({ "maple.webhook.deprovisioned": true }) + // Deliveries are unordered: an old one after a reactivation must not take new keys away. + const stillDeprovisioned = yield* sso.confirmDeprovisioned(userId.value) + if (!stillDeprovisioned) { + yield* Effect.annotateCurrentSpan({ + "http.response.status_code": 200, + "maple.webhook.outcome": "stale_deprovision", + }) + return webhookText("ok", 200) + } + return yield* revoke(revocation.revokeUser(userId.value)) + } + yield* Effect.annotateCurrentSpan({ + "http.response.status_code": 200, + "maple.webhook.outcome": "ignored", + }) + return webhookText("ok", 200) + } if (envelope.value.type === "user.deleted") { const payload = yield* decodeClerkUserDeleted(envelope.value.data).pipe(Effect.option) const rawId = Option.isSome(payload) ? payload.value.id : undefined diff --git a/apps/api/src/routes/webhooks/webhooks.http.test.ts b/apps/api/src/routes/webhooks/webhooks.http.test.ts index 49da6b6688..2e3abed674 100644 --- a/apps/api/src/routes/webhooks/webhooks.http.test.ts +++ b/apps/api/src/routes/webhooks/webhooks.http.test.ts @@ -1,6 +1,11 @@ import { assert, describe, it } from "@effect/vitest" import { BillingCustomerResolver } from "@maple/backend/services/billing/BillingCustomerResolver" -import { BillingAccountPersistenceError, BillingCustomerId, OrgId } from "@maple/domain/http" +import { + BillingAccountPersistenceError, + BillingCustomerId, + EnterpriseSsoUnavailableError, + OrgId, +} from "@maple/domain/http" import { Clock, ConfigProvider, Context, Effect, Layer, Schema, Array as Arr, String as Str } from "effect" import { HttpRouter } from "effect/http" import { EnvTestLive } from "@maple/backend/testing/env-test-support" @@ -15,6 +20,10 @@ import { } from "@maple/backend/services/product-events/ProductEventsService" import { signSvix } from "@maple/backend/services/product-events/svix" import { AuditLogService, type AuditLogRecordInput } from "@maple/backend/services/audit/AuditLogService" +import { + EnterpriseSsoService, + type DirectoryGroupEvent, +} from "@maple/backend/services/org/enterprise-sso/EnterpriseSsoService" import { MembershipRevocationService, MembershipRevocationError, @@ -133,6 +142,18 @@ const recordingCancellationQueue = (fail = false) => { return { queued, layer } } +/** Records directory-group webhooks; `owns` says whether this region holds the directory. */ +const recordingSso = (owns = true) => { + const applied: Array = [] + const layer = EnterpriseSsoService.webhookOnly((event) => + Effect.sync(() => { + applied.push(event) + return owns ? ("applied" as const) : ("not_here" as const) + }), + ) + return { applied, layer } +} + const makeRouterLayer = ( router: typeof ClerkWebhookRoute | typeof AutumnWebhookRouter, config: Record, @@ -142,8 +163,10 @@ const makeRouterLayer = ( cancellationQueue: Layer.Layer = recordingCancellationQueue().layer, billingCustomers: Layer.Layer = BillingCustomerResolver.standalone, regions: Layer.Layer = OrganizationRegionService.servesAll, + sso: Layer.Layer = recordingSso().layer, ) => router.pipe( + Layer.provide(sso), Layer.provide(productEvents), Layer.provide(regions), Layer.provide(billingCustomers), @@ -660,6 +683,146 @@ describe("ClerkWebhookRouter", () => { }).pipe(Effect.ensuring(Effect.promise(broken.dispose))) }), ) + + // SCIM: groups feed the role mapping picker; a deprovisioned user loses every credential. + it.live("stores directory groups and sweeps a deprovisioned user in every region", () => + Effect.gen(function* () { + const events = recordingProductEvents() + const revocation = recordingRevocation() + const sso = recordingSso() + const { handler, dispose } = HttpRouter.toWebHandler( + makeRouterLayer( + ClerkWebhookRoute, + { CLERK_WEBHOOK_SECRET: CLERK_SECRET }, + events.layer, + revocation.layer, + undefined, + undefined, + undefined, + // The org lives elsewhere: the sweep still runs here. + regionsAnswering("elsewhere", "eu"), + sso.layer, + ), + { disableLogger: true }, + ) + yield* Effect.gen(function* () { + const now = yield* Clock.currentTimeMillis + const send = (id: string, payload: unknown) => + Effect.gen(function* () { + const body = JSON.stringify(payload) + const headers = yield* signedHeaders(CLERK_SECRET, body, now, id) + return yield* post(handler, "/webhooks/clerk", body, headers) + }) + const group = { + id: "grp_1", + directory_id: "dir_1", + display_name: "Maple Admins", + updated_at: now, + } + + const created = yield* send("msg_g1", { type: "directoryGroup.created", data: group }) + assert.strictEqual(created.status, 200) + const removed = yield* send("msg_g2", { type: "directoryGroup.deleted", data: group }) + assert.strictEqual(removed.status, 200) + assert.deepStrictEqual( + Arr.map(sso.applied, (e) => [e.directoryId, e.groupId, e.displayName, e.deleted]), + [ + ["dir_1", "grp_1", "Maple Admins", false], + ["dir_1", "grp_1", "Maple Admins", true], + ], + ) + + const malformed = yield* send("msg_g3", { + type: "directoryGroup.created", + data: { id: "grp_2" }, + }) + assert.strictEqual(malformed.status, 400) + + // Reactivation and ordinary profile edits revoke nothing. + const active = yield* send("msg_u1", { + type: "user.updated", + data: { id: "user_5", deprovisioned: false }, + }) + const edited = yield* send("msg_u2", { type: "user.updated", data: { id: "user_5" } }) + assert.strictEqual(active.status, 200) + assert.strictEqual(edited.status, 200) + assert.deepStrictEqual(revocation.calls, []) + + const deprovisioned = yield* send("msg_u3", { + type: "user.updated", + data: { id: "user_5", deprovisioned: true }, + }) + assert.strictEqual(deprovisioned.status, 200) + assert.deepStrictEqual(revocation.calls, ["revokeUser:user_5"]) + }).pipe(Effect.ensuring(Effect.promise(dispose))) + }), + ) + + it.live("ignores a deprovision delivery Clerk no longer stands behind (the user was reactivated)", () => + Effect.gen(function* () { + const revocation = recordingRevocation() + const { handler, dispose } = HttpRouter.toWebHandler( + makeRouterLayer( + ClerkWebhookRoute, + { CLERK_WEBHOOK_SECRET: CLERK_SECRET }, + recordingProductEvents().layer, + revocation.layer, + undefined, + undefined, + undefined, + undefined, + EnterpriseSsoService.webhookOnly( + () => Effect.succeed("not_here" as const), + () => Effect.succeed(false), + ), + ), + { disableLogger: true }, + ) + yield* Effect.gen(function* () { + const now = yield* Clock.currentTimeMillis + const body = JSON.stringify({ + type: "user.updated", + data: { id: "user_7", deprovisioned: true }, + }) + const headers = yield* signedHeaders(CLERK_SECRET, body, now, "msg_stale") + const response = yield* post(handler, "/webhooks/clerk", body, headers) + assert.strictEqual(response.status, 200) + assert.deepStrictEqual(revocation.calls, []) + }).pipe(Effect.ensuring(Effect.promise(dispose))) + }), + ) + + it.live("500s a directory group the database could not save, so Clerk redelivers it", () => + Effect.gen(function* () { + const failing = EnterpriseSsoService.webhookOnly(() => + Effect.fail(new EnterpriseSsoUnavailableError({ message: "db down" })), + ) + const { handler, dispose } = HttpRouter.toWebHandler( + makeRouterLayer( + ClerkWebhookRoute, + { CLERK_WEBHOOK_SECRET: CLERK_SECRET }, + recordingProductEvents().layer, + undefined, + undefined, + undefined, + undefined, + undefined, + failing, + ), + { disableLogger: true }, + ) + yield* Effect.gen(function* () { + const now = yield* Clock.currentTimeMillis + const body = JSON.stringify({ + type: "directoryGroup.updated", + data: { id: "grp_1", directory_id: "dir_1", display_name: "Admins", updated_at: now }, + }) + const headers = yield* signedHeaders(CLERK_SECRET, body, now, "msg_gf") + const response = yield* post(handler, "/webhooks/clerk", body, headers) + assert.strictEqual(response.status, 500) + }).pipe(Effect.ensuring(Effect.promise(dispose))) + }), + ) }) const AUTUMN_CANCEL_SCHEDULED = JSON.stringify({ diff --git a/apps/api/src/runtime/http-graph.ts b/apps/api/src/runtime/http-graph.ts index 20b1003ec6..eb07bc7640 100644 --- a/apps/api/src/runtime/http-graph.ts +++ b/apps/api/src/runtime/http-graph.ts @@ -18,6 +18,7 @@ import { HttpGithubCostLive } from "@/routes/internal/github-cost.http" import { HttpOpenRouterCostLive } from "@/routes/internal/openrouter-cost.http" import { HttpCostBudgetsLive } from "@/routes/internal/cost-budgets.http" import { HttpOpenRouterKeyLive } from "@/routes/internal/openrouter-key.http" +import { HttpEnterpriseSsoLive } from "@/routes/internal/enterprise-sso.http" import { HttpPlanetScaleCostLive } from "@/routes/internal/planetscale-cost.http" import { HttpServiceMapWorldLive } from "@/routes/internal/service-map-world.http" import { HttpVercelCostLive } from "@/routes/internal/vercel-cost.http" @@ -187,6 +188,7 @@ const ApiInternalRoutes = HttpApiBuilder.layer(MapleInternalApi).pipe( HttpOpenRouterCostLive, HttpCostBudgetsLive, HttpOpenRouterKeyLive, + HttpEnterpriseSsoLive, HttpServiceMapWorldLive, HttpVercelCostLive, ), diff --git a/apps/api/src/runtime/service-graph.ts b/apps/api/src/runtime/service-graph.ts index a8b42d4591..47062c0836 100644 --- a/apps/api/src/runtime/service-graph.ts +++ b/apps/api/src/runtime/service-graph.ts @@ -94,6 +94,7 @@ import { CostBudgetsService } from "@maple/backend/services/cost/CostBudgetsServ import { PlanetScaleCostSourceService } from "@maple/backend/services/cost/PlanetScaleCostSourceService" import { VercelCostSourceService } from "@maple/backend/services/cost/VercelCostSourceService" import { OrgOpenRouterKeyService } from "@maple/backend/services/org/OrgOpenRouterKeyService" +import { EnterpriseSsoService } from "@maple/backend/services/org/enterprise-sso/EnterpriseSsoService" import { ServiceMapWorldService } from "@maple/backend/services/service-map/ServiceMapWorldService" import { ScrapeTargetsService } from "@maple/backend/services/integrations/ScrapeTargetsService" import { UptimeMonitorsService } from "@maple/backend/services/uptime/UptimeMonitorsService" @@ -238,6 +239,7 @@ export const HttpServicesLive = Layer.mergeAll( AwsConnectionService.layer, AwsIngestService.layer, OrgOpenRouterKeyService.layer, + EnterpriseSsoService.layer, OpenRouterCostConnectionService.layer, CloudflareCostConnectionService.layer, AnthropicCostConnectionService.layer, diff --git a/apps/web/src/page/settings/audit-log/icons.ts b/apps/web/src/page/settings/audit-log/icons.ts index ff852d0420..9b178f2d64 100644 --- a/apps/web/src/page/settings/audit-log/icons.ts +++ b/apps/web/src/page/settings/audit-log/icons.ts @@ -106,6 +106,22 @@ const VERB_ICONS = { pr_merged: "PullRequestIcon", merge: "BranchForkIcon", unmerge: "BranchForkIcon", + domain_added: "PlusIcon", + domain_verified: "ShieldCheckIcon", + domain_removed: "TrashIcon", + connection_created: "PlusIcon", + connection_updated: "PencilIcon", + connection_enforced: "LockIcon", + connection_relaxed: "PencilIcon", + connection_deleted: "TrashIcon", + directory_created: "PlusIcon", + directory_key_rotated: "ArrowRotateClockwiseIcon", + directory_paused: "MediaPauseIcon", + directory_resumed: "MediaPlayIcon", + directory_deleted: "TrashIcon", + role_mapping_updated: "ShieldIcon", + bypass_added: "PlusIcon", + bypass_removed: "TrashIcon", } as const satisfies { readonly [Verb in AuditVerb]: IconName } const hasVerbIcon = (verb: string): verb is keyof typeof VERB_ICONS => diff --git a/packages/backend/src/services/audit-trail/providers/maple.ts b/packages/backend/src/services/audit-trail/providers/maple.ts index 961a37dbbe..abd09c374e 100644 --- a/packages/backend/src/services/audit-trail/providers/maple.ts +++ b/packages/backend/src/services/audit-trail/providers/maple.ts @@ -13,6 +13,7 @@ const CATEGORY_BY_RESOURCE = { agent: "resource", agent_feedback: "other", ai_provider_key: "credential", + enterprise_sso: "authentication", alert_destination: "configuration", alert_rule: "configuration", alert_silence: "configuration", @@ -70,6 +71,8 @@ const CATEGORY_BY_RESOURCE = { const CATEGORY_BY_ACTION = { "source.rolled": "credential", "status_page.break_glass_rotated": "credential", + "enterprise_sso.directory_key_rotated": "credential", + "enterprise_sso.directory_created": "credential", "status_page.break_glass_revoked": "credential", "status_page.password_set": "credential", "status_page.password_removed": "credential", diff --git a/packages/backend/src/services/org/OrganizationService.ts b/packages/backend/src/services/org/OrganizationService.ts index b2b72a156a..c80dc1b4e7 100644 --- a/packages/backend/src/services/org/OrganizationService.ts +++ b/packages/backend/src/services/org/OrganizationService.ts @@ -172,6 +172,10 @@ const PURGE_ORDER: ReadonlyArray = [ "SupabaseConnections", // The org's own OpenRouter key: a recreated org with the same id must not inherit it. "OrgOpenRouterKeys", + // Enterprise SSO domains, connection ids and SCIM groups; the Clerk side goes with the Clerk org. + "OrgSsoDomains", + "OrgSsoConnections", + "OrgDirectoryGroups", // A surviving key would keep Maple reading the deleted org's OpenRouter spend. "OpenRouterCostConnections", // The same for every provider read with a pasted credential. diff --git a/packages/backend/src/services/org/enterprise-sso/ClerkSsoGateway.test.ts b/packages/backend/src/services/org/enterprise-sso/ClerkSsoGateway.test.ts new file mode 100644 index 0000000000..a56c41b2ef --- /dev/null +++ b/packages/backend/src/services/org/enterprise-sso/ClerkSsoGateway.test.ts @@ -0,0 +1,83 @@ +import { assert, describe, it } from "@effect/vitest" +import { Array as Arr, Effect } from "effect" +import { scanClaimedDomains } from "./ClerkSsoGateway" + +/** `total` connections, the last one serving `partner.io`; pages of 100 like Clerk's. */ +const connections = (total: number) => (offset: number) => + Effect.succeed({ + totalCount: total, + data: Arr.map(Arr.range(offset, Math.min(offset + 100, total) - 1), (i) => ({ + id: `ent_${i}`, + domains: i === total - 1 ? ["Partner.io"] : [`org${i}.example`], + })), + }) + +describe("scanClaimedDomains", () => { + it.effect("reads every page, so a connection on the last one still counts", () => + Effect.gen(function* () { + const claimed = yield* scanClaimedDomains(connections(250), "ent_0", ["partner.io", "gmail.com"]) + assert.deepStrictEqual(claimed, ["partner.io"]) + }), + ) + + it.effect("ignores the caller's own connection", () => + Effect.gen(function* () { + const claimed = yield* scanClaimedDomains(connections(3), "ent_2", ["partner.io"]) + assert.deepStrictEqual(claimed, []) + }), + ) + + it.effect("fails closed when the scan cannot reach every connection", () => + Effect.gen(function* () { + const error = yield* scanClaimedDomains(connections(250), "ent_0", ["partner.io"], 2).pipe( + Effect.flip, + ) + assert.strictEqual(error._tag, "@maple/backend/services/auth/ClerkRequestError") + }), + ) + + it.effect("fails closed when Clerk sends an empty page before its own total", () => + Effect.gen(function* () { + const short = (offset: number) => + offset === 0 ? connections(250)(0) : Effect.succeed({ totalCount: 250, data: [] }) + const error = yield* scanClaimedDomains(short, "ent_0", ["partner.io"]).pipe(Effect.flip) + assert.strictEqual(error._tag, "@maple/backend/services/auth/ClerkRequestError") + }), + ) + + it.effect("follows short pages by what Clerk returned, so no connection is skipped", () => { + const offsets: Array = [] + // 50 per page although the limit is 100; the partner connection is number 75. + const shortPages = (offset: number) => { + offsets.push(offset) + return Effect.succeed({ + totalCount: 150, + data: Arr.map(Arr.range(offset, Math.min(offset + 50, 150) - 1), (i) => ({ + id: `ent_${i}`, + domains: i === 75 ? ["partner.io"] : [`org${i}.example`], + })), + }) + } + return Effect.gen(function* () { + const claimed = yield* scanClaimedDomains(shortPages, "ent_0", ["partner.io"]) + assert.deepStrictEqual(claimed, ["partner.io"]) + assert.deepStrictEqual(offsets, [0, 50, 100]) + }) + }) + + it.effect("fails closed when a short page is followed by an empty one before the total", () => + Effect.gen(function* () { + const pages = (offset: number) => + Effect.succeed( + offset === 0 + ? { + totalCount: 100, + data: Arr.map(Arr.range(0, 49), (i) => ({ id: `ent_${i}`, domains: [] })), + } + : { totalCount: 100, data: [] }, + ) + const error = yield* scanClaimedDomains(pages, "ent_0", ["partner.io"]).pipe(Effect.flip) + assert.strictEqual(error._tag, "@maple/backend/services/auth/ClerkRequestError") + }), + ) +}) diff --git a/packages/backend/src/services/org/enterprise-sso/ClerkSsoGateway.ts b/packages/backend/src/services/org/enterprise-sso/ClerkSsoGateway.ts new file mode 100644 index 0000000000..fa388b58bf --- /dev/null +++ b/packages/backend/src/services/org/enterprise-sso/ClerkSsoGateway.ts @@ -0,0 +1,595 @@ +import type { ClerkClient, EnterpriseConnection } from "@clerk/backend" +import { clerkModeClient } from "@maple/auth" +import type { OrgId, SsoProvider, UserId } from "@maple/domain/http" +import { + Array as Arr, + Context, + Effect, + Layer, + Number as Num, + Option, + Order, + Predicate, + Redacted, + Schema, + String as Str, +} from "effect" +import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http" +import { Env } from "@maple/backend/platform/Env" +import { + CLERK_REQUEST_TIMEOUT, + ClerkRequestError, + clerkRequest, +} from "@maple/backend/services/auth/clerk-request" + +// Every Clerk call the SSO settings make. Directories, role mappings, the bypass allowlist and the +// domain ownership override are newer than @clerk/backend's methods, so those go over HTTP. + +type ConnectionApi = ClerkClient["enterpriseConnections"] +// @clerk/backend does not export its param types from the root. +type CreateEnterpriseConnectionParams = Parameters[0] +type UpdateEnterpriseConnectionParams = Parameters[1] +type EnterpriseConnectionSamlParams = NonNullable + +const CLERK_API_URL = "https://api.clerk.com/v1" +/** The version @clerk/backend 3.29 pins; every directory endpoint used here exists in it. */ +const CLERK_API_VERSION = "2026-05-12" + +export interface ClerkSsoConnection { + readonly id: string + readonly name: string + readonly provider: string + readonly domains: ReadonlyArray + readonly organizationId: string | null + readonly active: boolean + readonly createdAt: number + readonly saml: { + readonly acsUrl: string | null + readonly spEntityId: string | null + readonly spMetadataUrl: string | null + readonly idpMetadataUrl: string | null + readonly idpSsoUrl: string | null + readonly idpEntityId: string | null + readonly certificateExpiresAt: number | null + } | null + readonly oidc: { readonly discoveryUrl: string | null; readonly clientId: string | null } | null +} + +export interface ClerkSsoConnectionInput { + readonly name: string + readonly domains: ReadonlyArray + readonly saml?: { + readonly metadataUrl?: string + readonly ssoUrl?: string + readonly entityId?: string + readonly certificate?: string + } + readonly oidc?: { + readonly discoveryUrl: string + readonly clientId: string + readonly clientSecret?: string + } +} + +const DirectoryJson = Schema.Struct({ + id: Schema.String, + endpoint_url: Schema.String, + enabled: Schema.Boolean, + paused: Schema.Boolean, + group_role_mapping_enabled: Schema.Boolean, + created_at: Schema.Number, + api_key: Schema.optionalKey(Schema.NullOr(Schema.String)), +}) +export type ClerkSsoDirectory = typeof DirectoryJson.Type + +const RoleMappingJson = Schema.Struct({ + directory_group_id: Schema.optionalKey(Schema.NullOr(Schema.String)), + scim_group_id: Schema.optionalKey(Schema.NullOr(Schema.String)), + directory_group_display_name: Schema.optionalKey(Schema.NullOr(Schema.String)), + role: Schema.Struct({ id: Schema.String, key: Schema.String }), + precedence: Schema.Number, +}) +const byPrecedence = Order.mapInput(Num.Order, (m: { readonly precedence: number }) => m.precedence) +const UserFlags = Schema.Struct({ deprovisioned: Schema.optionalKey(Schema.NullOr(Schema.Boolean)) }) + +const CONNECTION_PAGE_SIZE = 100 +/** 100 pages of 100 connections; past that the scan refuses rather than guess. */ +const MAX_CONNECTION_PAGES = 100 + +interface ConnectionPage { + readonly data: ReadonlyArray<{ readonly id: string; readonly domains: ReadonlyArray }> + readonly totalCount: number +} + +/** + * Which of `domains` a connection other than `connectionId` serves, reading every page Clerk + * reports. Fails closed: a scan that cannot reach `totalCount` is an error, never a partial answer, + * since a miss would let a bypass change reach another org. + */ +export const scanClaimedDomains = ( + fetchPage: (offset: number) => Effect.Effect, + connectionId: string, + domains: ReadonlyArray, + maxPages: number = MAX_CONNECTION_PAGES, +): Effect.Effect, ClerkRequestError> => { + // The offset advances by what Clerk returned, never by the limit: a page may come back short. + const step = ( + page: number, + offset: number, + claimed: ReadonlySet, + ): Effect.Effect, ClerkRequestError> => + fetchPage(offset).pipe( + Effect.flatMap((result) => { + const next = new Set(claimed) + Arr.forEach(result.data, (conn) => { + if (conn.id !== connectionId) + Arr.forEach(conn.domains, (d) => next.add(Str.toLowerCase(d))) + }) + const read = offset + result.data.length + if (read >= result.totalCount) return Effect.succeed(next) + // An empty page short of the total, or the page budget spent: the scan is incomplete. + if (result.data.length === 0 || page + 1 >= maxPages) { + return Effect.fail( + new ClerkRequestError({ + operation: "Clerk.enterpriseConnections.list", + message: `Could not read all ${result.totalCount} enterprise connections`, + status: null, + cause: null, + }), + ) + } + return step(page + 1, read, next) + }), + ) + return step(0, 0, new Set()).pipe(Effect.map((claimed) => Arr.filter(domains, (d) => claimed.has(d)))) +} + +const RoleMappingList = Schema.Struct({ data: Schema.Array(RoleMappingJson) }) + +export interface ClerkSsoRoleMapping { + readonly groupId: string + readonly groupName: string | null + readonly roleKey: string +} + +const BypassUserJson = Schema.Struct({ + user_id: Schema.String, + public_user_data: Schema.optionalKey( + Schema.NullOr(Schema.Struct({ identifier: Schema.optionalKey(Schema.NullOr(Schema.String)) })), + ), +}) +const BypassUserList = Schema.Array(BypassUserJson) + +export interface ClerkSsoBypassUser { + readonly userId: string + readonly identifier: string | null +} + +export interface ClerkSsoGatewayApi { + /** False outside Clerk mode (self-hosted): there is no IdP integration to configure. */ + readonly available: boolean + readonly listRoles: Effect.Effect, ClerkRequestError> + /** Creates the organization domain, or finds it when the org already has it, and returns its id. */ + readonly ensureOrgDomain: (orgId: OrgId, domain: string) => Effect.Effect + /** Marks DNS ownership proven; Maple checked the TXT record itself. */ + readonly verifyOrgDomainOwnership: ( + orgId: OrgId, + domainId: string, + ) => Effect.Effect + readonly deleteOrgDomain: (orgId: OrgId, domainId: string) => Effect.Effect + readonly getConnection: (id: string) => Effect.Effect + readonly createConnection: ( + orgId: OrgId, + provider: SsoProvider, + input: ClerkSsoConnectionInput, + ) => Effect.Effect + readonly updateConnection: ( + id: string, + input: Partial & { readonly active?: boolean }, + ) => Effect.Effect + readonly deleteConnection: (id: string) => Effect.Effect + readonly createDirectory: ( + connectionId: string, + provider: "okta" | "entra" | "custom", + ) => Effect.Effect + readonly getDirectory: (id: string) => Effect.Effect + readonly updateDirectory: ( + id: string, + patch: { readonly paused?: boolean; readonly group_role_mapping_enabled?: boolean }, + ) => Effect.Effect + readonly rotateDirectoryKey: (id: string) => Effect.Effect + readonly deleteDirectory: (id: string) => Effect.Effect + /** Which of `domains` another enterprise connection in the instance serves. */ + readonly domainsClaimedElsewhere: ( + connectionId: string, + domains: ReadonlyArray, + ) => Effect.Effect, ClerkRequestError> + /** True when Clerk holds the user deprovisioned, or no longer has the user at all. */ + readonly isDeprovisioned: (userId: UserId) => Effect.Effect + readonly isMember: (orgId: OrgId, userId: UserId) => Effect.Effect + /** The domains of the user's verified email addresses, lower-cased. */ + readonly verifiedEmailDomains: (userId: UserId) => Effect.Effect, ClerkRequestError> + readonly listRoleMappings: ( + directoryId: string, + ) => Effect.Effect, ClerkRequestError> + readonly replaceRoleMappings: ( + directoryId: string, + mappings: ReadonlyArray<{ readonly groupId: string; readonly roleId: string }>, + ) => Effect.Effect + readonly listBypassUsers: ( + connectionId: string, + ) => Effect.Effect, ClerkRequestError> + readonly addBypassUser: (userId: UserId) => Effect.Effect + readonly removeBypassUser: (userId: UserId) => Effect.Effect +} + +const toConnection = (c: EnterpriseConnection): ClerkSsoConnection => ({ + id: c.id, + name: c.name, + provider: c.provider, + domains: c.domains, + organizationId: c.organizationId, + active: c.active, + createdAt: c.createdAt, + saml: + c.samlConnection === null + ? null + : { + acsUrl: c.samlConnection.acsUrl ?? null, + spEntityId: c.samlConnection.spEntityId ?? null, + spMetadataUrl: c.samlConnection.spMetadataUrl ?? null, + idpMetadataUrl: c.samlConnection.idpMetadataUrl || null, + idpSsoUrl: c.samlConnection.idpSsoUrl || null, + idpEntityId: c.samlConnection.idpEntityId || null, + certificateExpiresAt: c.samlConnection.idpCertificateExpiresAt ?? null, + }, + oidc: + c.oauthConfig === null + ? null + : { discoveryUrl: c.oauthConfig.discoveryUrl ?? null, clientId: c.oauthConfig.clientId ?? null }, +}) + +const samlParams = (saml: NonNullable): EnterpriseConnectionSamlParams => { + if (saml.metadataUrl !== undefined) return { idpMetadataUrl: saml.metadataUrl } + const params: EnterpriseConnectionSamlParams = { idpSsoUrl: saml.ssoUrl, idpEntityId: saml.entityId } + if (saml.certificate !== undefined) params.idpCertificates = [saml.certificate] + return params +} + +const createParams = ( + orgId: OrgId, + provider: SsoProvider, + input: ClerkSsoConnectionInput, +): CreateEnterpriseConnectionParams => { + const params: CreateEnterpriseConnectionParams = { + name: input.name, + domains: [...input.domains], + organizationId: orgId, + provider, + // Never live on create: the admin enforces it once a sign-in works. + active: false, + allowOrganizationAccountLinking: true, + } + if (input.saml !== undefined) params.saml = samlParams(input.saml) + if (input.oidc !== undefined) params.oidc = input.oidc + return params +} + +/** Clerk's update body: only what the caller set, so an omitted secret keeps the stored one. */ +const updateParams = ( + input: Partial & { readonly active?: boolean }, +): UpdateEnterpriseConnectionParams => { + const params: UpdateEnterpriseConnectionParams = {} + if (input.name !== undefined) params.name = input.name + if (input.domains !== undefined) params.domains = [...input.domains] + if (input.active !== undefined) params.active = input.active + if (input.saml !== undefined) params.saml = samlParams(input.saml) + if (input.oidc !== undefined) params.oidc = input.oidc + return params +} + +/** Clerk's error body is `{ errors: [{ message, long_message }] }`; the long message is user-facing. */ +const clerkErrorMessage = (body: unknown): string | null => { + if (!Predicate.isObject(body) || !Predicate.hasProperty(body, "errors") || !Arr.isArray(body.errors)) { + return null + } + const first: unknown = body.errors[0] + if (!Predicate.isObject(first)) return null + if (Predicate.hasProperty(first, "long_message") && Predicate.isString(first.long_message)) { + return first.long_message + } + return Predicate.hasProperty(first, "message") && Predicate.isString(first.message) ? first.message : null +} + +const make = Effect.gen(function* () { + const env = yield* Env + const httpClient = yield* HttpClient.HttpClient + const clerk: ClerkClient | null = clerkModeClient(env) ?? null + const secret = Option.getOrNull(env.CLERK_SECRET_KEY) + + const notConfigured = (operation: string) => + new ClerkRequestError({ operation, message: "Clerk is not configured", status: null, cause: null }) + + const sdk = ( + operation: string, + attributes: Readonly>, + run: (client: ClerkClient) => Promise, + ): Effect.Effect => + clerk === null + ? Effect.fail(notConfigured(operation)) + : clerkRequest(operation, attributes, () => run(clerk)) + + /** One raw Backend API call: JSON in, JSON out, Clerk's message kept on a non-2xx. */ + const raw = ( + operation: string, + method: "GET" | "POST" | "PATCH" | "PUT" | "DELETE", + path: string, + options: { readonly body?: unknown; readonly decode?: S } = {}, + ): Effect.Effect => + Effect.gen(function* () { + if (secret === null) return yield* notConfigured(operation) + const base = HttpClientRequest.make(method)(`${CLERK_API_URL}${path}`).pipe( + HttpClientRequest.bearerToken(Redacted.value(secret)), + HttpClientRequest.setHeader("Clerk-API-Version", CLERK_API_VERSION), + HttpClientRequest.acceptJson, + ) + const request = + options.body === undefined ? base : HttpClientRequest.bodyJsonUnsafe(base, options.body) + const response = yield* httpClient.execute(request) + const body: unknown = yield* response.json.pipe(Effect.orElseSucceed(() => null)) + if (response.status >= 300) { + return yield* new ClerkRequestError({ + operation, + message: clerkErrorMessage(body) ?? `Clerk answered ${response.status}`, + status: response.status, + cause: null, + }) + } + if (options.decode === undefined) return undefined + return yield* Schema.decodeUnknownEffect(options.decode)(body) + }).pipe( + Effect.catchTags({ + HttpClientError: (cause) => + Effect.fail( + new ClerkRequestError({ operation, message: cause.message, status: null, cause }), + ), + SchemaError: () => + Effect.fail( + new ClerkRequestError({ + operation, + message: "Clerk answered in an unexpected shape", + status: null, + // The decode error can quote the body, which may hold a SCIM key: not kept. + cause: null, + }), + ), + }), + Effect.timeoutOrElse({ + duration: CLERK_REQUEST_TIMEOUT, + orElse: () => + Effect.fail( + new ClerkRequestError({ + operation, + message: "Clerk timed out", + status: null, + cause: null, + }), + ), + }), + Effect.withSpan(operation, { + kind: "client", + attributes: { "peer.service": "clerk", "http.request.method": method }, + }), + ) + + const directory = (operation: string, method: "GET" | "POST" | "PATCH", path: string, body?: unknown) => + raw(operation, method, path, { body, decode: DirectoryJson }).pipe( + Effect.filterOrFail( + (d): d is ClerkSsoDirectory => d !== undefined, + () => + new ClerkRequestError({ + operation, + message: "Clerk sent no directory", + status: null, + cause: null, + }), + ), + ) + + const api: ClerkSsoGatewayApi = { + available: clerk !== null && secret !== null, + listRoles: sdk("Clerk.organizationRoles.list", {}, (c) => + c.organizationRoles.getOrganizationRoleList({ limit: 100 }), + ).pipe(Effect.map((page) => Arr.map(page.data, (role) => ({ id: role.id, key: role.key })))), + ensureOrgDomain: (orgId, domain) => + sdk("Clerk.organizations.createOrganizationDomain", { orgId }, (c) => + c.organizations.createOrganizationDomain({ + organizationId: orgId, + name: domain, + enrollmentMode: "manual_invitation", + verified: true, + }), + ).pipe( + Effect.map((d) => d.id), + // Already on the org (the Domains tab added it): reuse that one. + Effect.catchIf( + (error) => error.status === 422 || error.status === 409 || error.status === 400, + (error) => + sdk("Clerk.organizations.getOrganizationDomainList", { orgId }, async (c) => { + const all: Array<{ readonly id: string; readonly name: string }> = [] + for (let offset = 0; offset < 1_000; offset += 100) { + const page = await c.organizations.getOrganizationDomainList({ + organizationId: orgId, + limit: 100, + offset, + }) + all.push(...page.data) + if (page.data.length < 100) break + } + return { data: all } + }).pipe( + Effect.flatMap((page) => { + const found = Arr.findFirst(page.data, (d) => d.name === domain) + return Option.match(found, { + onNone: () => Effect.fail(error), + onSome: (d) => Effect.succeed(d.id), + }) + }), + ), + ), + ), + verifyOrgDomainOwnership: (orgId, domainId) => + raw( + "Clerk.organizationDomains.verifyOwnership", + "POST", + `/organizations/${encodeURIComponent(orgId)}/domains/${encodeURIComponent(domainId)}/verify_ownership`, + ).pipe(Effect.asVoid), + deleteOrgDomain: (orgId, domainId) => + sdk("Clerk.organizations.deleteOrganizationDomain", { orgId }, (c) => + c.organizations.deleteOrganizationDomain({ organizationId: orgId, domainId }), + ).pipe(Effect.asVoid), + getConnection: (id) => + sdk("Clerk.enterpriseConnections.get", {}, (c) => + c.enterpriseConnections.getEnterpriseConnection(id), + ).pipe(Effect.map(toConnection)), + createConnection: (orgId, provider, input) => + sdk("Clerk.enterpriseConnections.create", { orgId, provider }, (c) => + c.enterpriseConnections.createEnterpriseConnection(createParams(orgId, provider, input)), + ).pipe(Effect.map(toConnection)), + updateConnection: (id, input) => + sdk("Clerk.enterpriseConnections.update", {}, (c) => + c.enterpriseConnections.updateEnterpriseConnection(id, updateParams(input)), + ).pipe(Effect.map(toConnection)), + deleteConnection: (id) => + sdk("Clerk.enterpriseConnections.delete", {}, (c) => + c.enterpriseConnections.deleteEnterpriseConnection(id), + ).pipe(Effect.asVoid), + createDirectory: (connectionId, provider) => + directory("Clerk.directories.create", "POST", "/directories", { + enterprise_connection_id: connectionId, + provider, + name: "Maple SCIM", + }), + getDirectory: (id) => + directory("Clerk.directories.get", "GET", `/directories/${encodeURIComponent(id)}`), + updateDirectory: (id, patch) => + directory("Clerk.directories.update", "PATCH", `/directories/${encodeURIComponent(id)}`, patch), + rotateDirectoryKey: (id) => + directory( + "Clerk.directories.rotateApiKey", + "POST", + `/directories/${encodeURIComponent(id)}/rotate_api_key`, + ), + deleteDirectory: (id) => + raw("Clerk.directories.delete", "DELETE", `/directories/${encodeURIComponent(id)}`).pipe( + Effect.asVoid, + ), + domainsClaimedElsewhere: (connectionId, domains) => + domains.length === 0 + ? Effect.succeed([]) + : scanClaimedDomains( + (offset) => + sdk("Clerk.enterpriseConnections.list", { offset }, (c) => + c.enterpriseConnections.getEnterpriseConnectionList({ + limit: CONNECTION_PAGE_SIZE, + offset, + }), + ), + connectionId, + domains, + ), + isDeprovisioned: (userId) => + raw("Clerk.users.get", "GET", `/users/${encodeURIComponent(userId)}`, { decode: UserFlags }).pipe( + Effect.map((user) => user?.deprovisioned === true), + Effect.catchIf( + (e) => e.status === 404, + () => Effect.succeed(true), + ), + ), + isMember: (orgId, userId) => + sdk("Clerk.organizations.getOrganizationMembershipList", { orgId }, (c) => + c.organizations.getOrganizationMembershipList({ + organizationId: orgId, + userId: [userId], + limit: 1, + }), + ).pipe(Effect.map((page) => page.data.length > 0)), + verifiedEmailDomains: (userId) => + sdk("Clerk.users.getUser", {}, (c) => c.users.getUser(userId)).pipe( + Effect.map((user) => + Arr.flatMap(user.emailAddresses, (e) => + e.verification?.status === "verified" + ? Option.toArray( + Option.map(Arr.last(Str.split(e.emailAddress, "@")), Str.toLowerCase), + ) + : [], + ), + ), + ), + listRoleMappings: (directoryId) => + raw( + "Clerk.directories.listGroupRoleMappings", + "GET", + `/directories/${encodeURIComponent(directoryId)}/group_role_mappings`, + { + decode: RoleMappingList, + }, + ).pipe( + Effect.map((list) => + Arr.map(Arr.sort(list?.data ?? [], byPrecedence), (m) => ({ + groupId: m.directory_group_id ?? m.scim_group_id ?? "", + groupName: m.directory_group_display_name ?? null, + roleKey: m.role.key, + })), + ), + ), + replaceRoleMappings: (directoryId, mappings) => + raw( + "Clerk.directories.replaceGroupRoleMappings", + "PUT", + `/directories/${encodeURIComponent(directoryId)}/group_role_mappings`, + { + body: { + mappings: Arr.map(mappings, (m) => ({ + directory_group_id: m.groupId, + role_id: m.roleId, + })), + }, + }, + ).pipe(Effect.asVoid), + listBypassUsers: (connectionId) => + raw( + "Clerk.ssoBypassAllowlist.list", + "GET", + `/sso_bypass_allowlist_users?enterprise_connection_id=${encodeURIComponent(connectionId)}`, + { + decode: BypassUserList, + }, + ).pipe( + Effect.map((list) => + Arr.map(list ?? [], (u) => ({ + userId: u.user_id, + identifier: u.public_user_data?.identifier ?? null, + })), + ), + ), + addBypassUser: (userId) => + raw("Clerk.ssoBypassAllowlist.create", "POST", "/sso_bypass_allowlist_users", { + body: { user_id: userId }, + }).pipe(Effect.asVoid), + removeBypassUser: (userId) => + raw( + "Clerk.ssoBypassAllowlist.delete", + "DELETE", + `/sso_bypass_allowlist_users/${encodeURIComponent(userId)}`, + ).pipe(Effect.asVoid), + } + return api +}) + +export class ClerkSsoGateway extends Context.Service()( + "@maple/backend/services/org/enterprise-sso/ClerkSsoGateway", + { make }, +) { + static readonly layer = Layer.effect(this, this.make).pipe(Layer.provide(FetchHttpClient.layer)) +} diff --git a/packages/backend/src/services/org/enterprise-sso/DnsTxtResolver.test.ts b/packages/backend/src/services/org/enterprise-sso/DnsTxtResolver.test.ts new file mode 100644 index 0000000000..ed5d14b304 --- /dev/null +++ b/packages/backend/src/services/org/enterprise-sso/DnsTxtResolver.test.ts @@ -0,0 +1,60 @@ +import { assert, describe, it } from "@effect/vitest" +import { Effect, Layer } from "effect" +import { FetchHttpClient } from "effect/http" +import { DnsTxtResolver } from "./DnsTxtResolver" + +const resolverAnswering = (status: number, body: unknown, urls: Array = []) => + Layer.effect(DnsTxtResolver, DnsTxtResolver.make).pipe( + Layer.provide(FetchHttpClient.layer), + Layer.provide( + Layer.succeed(FetchHttpClient.Fetch, (async (input: string | URL | Request) => { + urls.push(typeof input === "string" ? input : input instanceof URL ? input.href : input.url) + return new Response(JSON.stringify(body), { status }) + }) as typeof fetch), + ), + ) + +describe("DnsTxtResolver", () => { + it.effect("joins split TXT strings and drops other record types", () => { + const urls: Array = [] + return Effect.gen(function* () { + const dns = yield* DnsTxtResolver + const values = yield* dns.lookupTxt("_maple-challenge.acme.com") + assert.deepStrictEqual(values, ["maple-domain-verification=abc123", 'say "hi"']) + assert.include(urls[0], "name=_maple-challenge.acme.com") + assert.include(urls[0], "type=TXT") + }).pipe( + Effect.provide( + resolverAnswering( + 200, + { + Status: 0, + Answer: [ + { type: 5, data: "alias.acme.com." }, + { type: 16, data: '"maple-domain-verification=" "abc123"' }, + { type: 16, data: '"say \\"hi\\""' }, + ], + }, + urls, + ), + ), + ) + }) + + it.effect("reads a missing name as no records, and a resolver failure as an error", () => + Effect.gen(function* () { + const missing = yield* DnsTxtResolver.pipe( + Effect.flatMap((dns) => dns.lookupTxt("_maple-challenge.nope.example")), + Effect.provide(resolverAnswering(200, { Status: 3 })), + ) + assert.deepStrictEqual(missing, []) + + const servfail = yield* DnsTxtResolver.pipe( + Effect.flatMap((dns) => dns.lookupTxt("_maple-challenge.acme.com")), + Effect.flip, + Effect.provide(resolverAnswering(200, { Status: 2 })), + ) + assert.strictEqual(servfail._tag, "@maple/backend/services/org/enterprise-sso/DnsLookupError") + }), + ) +}) diff --git a/packages/backend/src/services/org/enterprise-sso/DnsTxtResolver.ts b/packages/backend/src/services/org/enterprise-sso/DnsTxtResolver.ts new file mode 100644 index 0000000000..ab358f3b56 --- /dev/null +++ b/packages/backend/src/services/org/enterprise-sso/DnsTxtResolver.ts @@ -0,0 +1,78 @@ +import { Array as Arr, Context, Duration, Effect, Layer, Option, Schema, String as Str } from "effect" +import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http" + +export class DnsLookupError extends Schema.TaggedError()( + "@maple/backend/services/org/enterprise-sso/DnsLookupError", + { recordName: Schema.String, message: Schema.String }, +) {} + +const DohAnswer = Schema.Struct({ + Status: Schema.Number, + Answer: Schema.optionalKey(Schema.Array(Schema.Struct({ type: Schema.Number, data: Schema.String }))), +}) + +const TXT = 16 +const TXT_STRING = /"((?:[^"\\]|\\.)*)"/g +/** NOERROR and NXDOMAIN are answers; anything else (SERVFAIL, REFUSED) is a failed lookup. */ +const NXDOMAIN = 3 + +/** A TXT record's character-strings joined, with the presentation quotes removed. */ +export const txtValue = (data: string): string => { + const parts = Option.getOrElse(Str.match(TXT_STRING)(data), (): ReadonlyArray => [data]) + return Arr.join( + Arr.map(parts, (part) => Str.replaceAll('\\"', '"')(Str.replace(/^"|"$/g, "")(part))), + "", + ) +} + +export interface DnsTxtResolverApi { + /** Every TXT value at `name`; empty when the name has none or does not exist. */ + readonly lookupTxt: (name: string) => Effect.Effect, DnsLookupError> +} + +/** DNS over HTTPS against Cloudflare's resolver: Workers have no raw DNS, and it works in both regions. */ +const make = Effect.gen(function* () { + const httpClient = yield* HttpClient.HttpClient + const lookupTxt = Effect.fn("DnsTxtResolver.lookupTxt")(function* (name: string) { + yield* Effect.annotateCurrentSpan({ "dns.question.name": name }) + const fail = (message: string) => new DnsLookupError({ recordName: name, message }) + const response = yield* httpClient + .execute( + HttpClientRequest.get("https://cloudflare-dns.com/dns-query").pipe( + HttpClientRequest.setUrlParams({ name, type: "TXT" }), + HttpClientRequest.setHeader("accept", "application/dns-json"), + ), + ) + .pipe( + Effect.mapError((error) => fail(error.message)), + Effect.timeoutOrElse({ + duration: Duration.seconds(5), + orElse: () => Effect.fail(fail("DNS lookup timed out")), + }), + // Client-kind so the service map draws the DoH resolver as a dependency. + Effect.withSpan("DNS-over-HTTPS TXT", { + kind: "client", + attributes: { "peer.service": "cloudflare-dns", "dns.question.name": name }, + }), + ) + if (response.status !== 200) return yield* fail(`DNS resolver answered ${response.status}`) + const body = yield* response.json.pipe( + Effect.flatMap(Schema.decodeUnknownEffect(DohAnswer)), + Effect.mapError(() => fail("DNS resolver answered in an unexpected shape")), + ) + if (body.Status === NXDOMAIN) return [] + if (body.Status !== 0) return yield* fail(`DNS lookup failed with status ${body.Status}`) + return Arr.map( + Arr.filter(body.Answer ?? [], (a) => a.type === TXT), + (a) => txtValue(a.data), + ) + }) + return { lookupTxt } satisfies DnsTxtResolverApi +}) + +export class DnsTxtResolver extends Context.Service()( + "@maple/backend/services/org/enterprise-sso/DnsTxtResolver", + { make }, +) { + static readonly layer = Layer.effect(this, this.make).pipe(Layer.provide(FetchHttpClient.layer)) +} diff --git a/packages/backend/src/services/org/enterprise-sso/EnterpriseSsoService.test.ts b/packages/backend/src/services/org/enterprise-sso/EnterpriseSsoService.test.ts new file mode 100644 index 0000000000..61e2ef450a --- /dev/null +++ b/packages/backend/src/services/org/enterprise-sso/EnterpriseSsoService.test.ts @@ -0,0 +1,835 @@ +import { afterEach, assert, describe, it } from "@effect/vitest" +import { BillingCustomerResolver } from "@maple/backend/services/billing/BillingCustomerResolver" +import { Array as Arr, ConfigProvider, Effect, Exit, Layer, Option, Schema, String as Str } from "effect" +import { EdgeCacheService, MemoryCacheBackendLive } from "@maple/cache" +import { OrgId, SsoConnectionRequest, SsoSamlSettings, UserId } from "@maple/domain/http" +import { Env } from "@maple/backend/platform/Env" +import { cleanupTestDbs, createTestDb, queryFirstRow, type TestDb } from "@maple/backend/testing/test-pglite" +import { AutumnClient, type AutumnResult } from "@maple/backend/services/billing/autumn-http" +import { ClerkRequestError } from "@maple/backend/services/auth/clerk-request" +import { ClerkSsoGateway, type ClerkSsoConnection, type ClerkSsoDirectory } from "./ClerkSsoGateway" +import { DnsTxtResolver } from "./DnsTxtResolver" +import { EnterpriseSsoService } from "./EnterpriseSsoService" + +const trackedDbs: TestDb[] = [] +afterEach(() => cleanupTestDbs(trackedDbs)) + +const ORG = Schema.decodeSync(OrgId)("org_acme") +const OTHER_ORG = Schema.decodeSync(OrgId)("org_other") +const ADMIN = Schema.decodeSync(UserId)("user_admin") +const BREAK_GLASS = Schema.decodeSync(UserId)("user_breakglass") + +/** Clerk as far as the SSO settings use it, kept in memory so each call's effect can be asserted. */ +interface FakeClerk { + connections: Map + directories: Map + verifiedDomains: Array + mappings: Map> + bypass: Array + /** Org members, and each user's verified email domains. */ + members: Set + /** What Clerk says about a deprovisioned user now, or that it cannot be reached. */ + deprovisioned: "yes" | "no" | "unreachable" + deprovisionLookups: number + emailDomains: Map> + nextId: number + /** The next `createConnection` fails with this Clerk status and message. */ + rejectCreate: { status: number; message: string } | null +} + +const ROLES = [ + { id: "role_admin", key: "org:admin" }, + { id: "role_engineer", key: "org:engineer" }, + { id: "role_member", key: "org:member" }, + { id: "role_analyst", key: "org:analyst" }, +] + +const fakeClerk = (): FakeClerk => ({ + connections: new Map(), + directories: new Map(), + verifiedDomains: [], + mappings: new Map(), + bypass: [], + deprovisioned: "yes", + deprovisionLookups: 0, + members: new Set(["user_admin", "user_breakglass", "user_contractor", "user_dual"]), + emailDomains: new Map([ + ["user_breakglass", ["acme.com"]], + ["user_contractor", ["gmail.com"]], + ["user_outsider", ["acme.com"]], + ["user_dual", ["acme.com", "partner.io"]], + ]), + nextId: 1, + rejectCreate: null, +}) + +const notFound = (operation: string) => + new ClerkRequestError({ operation, message: "not found", status: 404, cause: null }) + +const gatewayLayer = (clerk: FakeClerk) => + Layer.succeed(ClerkSsoGateway, { + available: true, + listRoles: Effect.succeed(ROLES), + ensureOrgDomain: (orgId, domain) => Effect.succeed(`dmn_${orgId}_${domain}`), + verifyOrgDomainOwnership: (_orgId, domainId) => + Effect.sync(() => void clerk.verifiedDomains.push(domainId)), + deleteOrgDomain: () => Effect.void, + getConnection: (id) => { + const c = clerk.connections.get(id) + return c === undefined ? Effect.fail(notFound("get")) : Effect.succeed(c) + }, + createConnection: (orgId, provider, input) => + Effect.suspend(() => { + if (clerk.rejectCreate !== null) { + const { status, message } = clerk.rejectCreate + return Effect.fail( + new ClerkRequestError({ operation: "create", message, status, cause: null }), + ) + } + const id = `ent_${clerk.nextId++}` + const c: ClerkSsoConnection = { + id, + name: input.name, + provider, + domains: input.domains, + organizationId: orgId, + active: false, + createdAt: 1_760_000_000_000, + saml: Str.startsWith("saml_")(provider) + ? { + acsUrl: `https://clerk.test/v1/saml/acs/${id}`, + spEntityId: `https://clerk.test/saml/${id}`, + spMetadataUrl: `https://clerk.test/v1/saml/metadata/${id}`, + idpMetadataUrl: input.saml?.metadataUrl ?? null, + idpSsoUrl: input.saml?.ssoUrl ?? null, + idpEntityId: input.saml?.entityId ?? null, + certificateExpiresAt: null, + } + : null, + oidc: + input.oidc === undefined + ? null + : { discoveryUrl: input.oidc.discoveryUrl, clientId: input.oidc.clientId }, + } + clerk.connections.set(id, c) + return Effect.succeed(c) + }), + updateConnection: (id, input) => + Effect.suspend(() => { + const c = clerk.connections.get(id) + if (c === undefined) return Effect.fail(notFound("update")) + const next = { + ...c, + name: input.name ?? c.name, + domains: input.domains ?? c.domains, + active: input.active ?? c.active, + } + clerk.connections.set(id, next) + return Effect.succeed(next) + }), + deleteConnection: (id) => Effect.sync(() => void clerk.connections.delete(id)), + createDirectory: (connectionId, provider) => + Effect.sync(() => { + const id = `dir_${clerk.nextId++}` + const d = { + id, + connectionId, + endpoint_url: `https://scim.clerk.test/${id}/${provider}`, + enabled: true, + paused: false, + group_role_mapping_enabled: false, + created_at: 1_760_000_000_000, + api_key: `scim_${clerk.nextId++}`, + } + clerk.directories.set(id, d) + return d + }), + getDirectory: (id) => { + const d = clerk.directories.get(id) + return d === undefined ? Effect.fail(notFound("dir")) : Effect.succeed({ ...d, api_key: null }) + }, + updateDirectory: (id, patch) => + Effect.suspend(() => { + const d = clerk.directories.get(id) + if (d === undefined) return Effect.fail(notFound("dir")) + const next = { ...d, ...patch } + clerk.directories.set(id, next) + return Effect.succeed({ ...next, api_key: null }) + }), + rotateDirectoryKey: (id) => + Effect.suspend(() => { + const d = clerk.directories.get(id) + if (d === undefined) return Effect.fail(notFound("dir")) + const next = { ...d, api_key: `scim_${clerk.nextId++}` } + clerk.directories.set(id, next) + return Effect.succeed(next) + }), + deleteDirectory: (id) => Effect.sync(() => void clerk.directories.delete(id)), + listRoleMappings: (directoryId) => + Effect.sync(() => + Arr.map(clerk.mappings.get(directoryId) ?? [], (m) => ({ + groupId: m.groupId, + groupName: null, + roleKey: Option.getOrElse( + Option.map( + Arr.findFirst(ROLES, (r) => r.id === m.roleId), + (r) => r.key, + ), + () => "unknown", + ), + })), + ), + replaceRoleMappings: (directoryId, mappings) => + Effect.sync(() => void clerk.mappings.set(directoryId, [...mappings])), + domainsClaimedElsewhere: (connectionId, domains) => + Effect.sync(() => + Arr.filter(domains, (d) => + Arr.some( + [...clerk.connections.values()], + (c) => c.id !== connectionId && Arr.contains(c.domains, d), + ), + ), + ), + isDeprovisioned: () => + Effect.suspend(() => { + clerk.deprovisionLookups++ + return clerk.deprovisioned === "unreachable" + ? Effect.fail( + new ClerkRequestError({ + operation: "get", + message: "down", + status: 503, + cause: null, + }), + ) + : Effect.succeed(clerk.deprovisioned === "yes") + }), + isMember: (_orgId, userId) => Effect.sync(() => clerk.members.has(userId)), + verifiedEmailDomains: (userId) => Effect.sync(() => clerk.emailDomains.get(userId) ?? []), + listBypassUsers: () => + Effect.sync(() => + Arr.map(clerk.bypass, (userId) => ({ userId, identifier: `${userId}@acme.com` })), + ), + addBypassUser: (userId) => Effect.sync(() => void clerk.bypass.push(userId)), + removeBypassUser: (userId) => + Effect.sync(() => void (clerk.bypass = Arr.filter(clerk.bypass, (u) => u !== userId))), + }) + +/** Published TXT records by name. */ +const dnsLayer = (records: Map>) => + Layer.succeed(DnsTxtResolver, { lookupTxt: (name) => Effect.succeed(records.get(name) ?? []) }) + +const die = () => Effect.die(new Error("not used by this test")) + +const autumnStub = (entitled: boolean) => + Layer.succeed(AutumnClient, { + getOrCreateCustomer: () => + Effect.succeed({ + statusCode: 200, + response: { + id: ORG, + flags: entitled ? { enterprise_sso: { featureId: "enterprise_sso" } } : {}, + }, + }), + aggregateEvents: die, + attach: die, + previewAttach: die, + openCustomerPortal: die, + listPlans: die, + applyReward: die, + cancelPlans: die, + updateCustomerBillingControls: die, + updateCustomerName: die, + }) + +const config = ConfigProvider.layer( + ConfigProvider.fromUnknown({ + PORT: "3472", + TINYBIRD_HOST: "https://api.tinybird.co", + TINYBIRD_TOKEN: "test-token", + MAPLE_AUTH_MODE: "self_hosted", + MAPLE_ROOT_PASSWORD: "test-root-password", + MAPLE_DEFAULT_ORG_ID: "default", + MAPLE_INGEST_KEY_ENCRYPTION_KEY: Buffer.alloc(32, 9).toString("base64"), + MAPLE_INGEST_KEY_LOOKUP_HMAC_KEY: "maple-test-lookup-secret", + MAPLE_INGEST_PUBLIC_URL: "https://ingest.test", + }), +) + +const run = ( + testDb: TestDb, + world: { clerk: FakeClerk; dns: Map>; entitled: boolean }, + effect: Effect.Effect, +) => + effect.pipe( + Effect.provide( + Layer.effect(EnterpriseSsoService, EnterpriseSsoService.make).pipe( + Layer.provide( + Layer.mergeAll( + autumnStub(world.entitled), + EdgeCacheService.layer.pipe(Layer.provide(MemoryCacheBackendLive)), + BillingCustomerResolver.standalone, + gatewayLayer(world.clerk), + dnsLayer(world.dns), + ), + ), + Layer.provide(testDb.layer), + Layer.provide(Env.layer), + Layer.provide(config), + ), + ), + ) + +const samlRequest = (domains: Array) => + new SsoConnectionRequest({ + name: "Acme Okta", + provider: "saml_okta", + domains, + saml: { metadataUrl: "https://acme.okta.com/app/abc/sso/saml/metadata" }, + }) + +/** Adds a domain and publishes its challenge, the way an admin would at their DNS host. */ +const verifiedDomain = (dns: Map>, domain: string) => + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + const added = yield* sso.addDomain(ORG, ADMIN, domain) + const row = Arr.findFirst(added.domains, (d) => d.domain === domain) + assert.isTrue(Option.isSome(row)) + if (Option.isSome(row)) dns.set(row.value.recordName, ["v=spf1 -all", row.value.recordValue]) + return yield* sso.verifyDomain(ORG, domain) + }) + +describe("EnterpriseSsoService", () => { + it.effect("verifies a domain by TXT, connects an IdP inactive, enforces it, and provisions SCIM", () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + + const added = yield* sso.addDomain(ORG, ADMIN, " Acme.COM. ") + assert.deepStrictEqual( + Arr.map(added.domains, (d) => [d.domain, d.status, d.recordName]), + [["acme.com", "pending", "_maple-challenge.acme.com"]], + ) + assert.match(added.domains[0]?.recordValue ?? "", /^maple-domain-verification=[0-9a-f]{32}$/) + + // No record published yet: refused, and nothing reaches Clerk. + const early = yield* sso.verifyDomain(ORG, "acme.com").pipe(Effect.flip) + assert.strictEqual(early._tag, "@maple/http/enterprise-sso/EnterpriseSsoInvalidError") + assert.deepStrictEqual(world.clerk.verifiedDomains, []) + + // Another org's challenge does not prove this org's claim. + world.dns.set("_maple-challenge.acme.com", ["maple-domain-verification=someone-else"]) + const wrong = yield* sso.verifyDomain(ORG, "acme.com").pipe(Effect.flip) + assert.strictEqual(wrong._tag, "@maple/http/enterprise-sso/EnterpriseSsoInvalidError") + + const verified = yield* verifiedDomain(world.dns, "acme.com") + assert.strictEqual(verified.domains[0]?.status, "verified") + assert.deepStrictEqual(world.clerk.verifiedDomains, ["dmn_org_acme_acme.com"]) + + // Only verified domains may route sign-ins to an IdP. + yield* sso.addDomain(ORG, ADMIN, "acme.io") + const unverified = yield* sso + .createConnection(ORG, ADMIN, samlRequest(["acme.com", "acme.io"])) + .pipe(Effect.flip) + assert.strictEqual(unverified._tag, "@maple/http/enterprise-sso/EnterpriseSsoInvalidError") + assert.strictEqual(world.clerk.connections.size, 0) + + const connected = yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + assert.strictEqual(connected.connection?.enforced, false) + assert.strictEqual(connected.connection?.protocol, "saml") + assert.match(connected.connection?.acsUrl ?? "", /^https:\/\/clerk\.test\/v1\/saml\/acs\//) + + const again = yield* sso + .createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + .pipe(Effect.flip) + assert.strictEqual(again._tag, "@maple/http/enterprise-sso/EnterpriseSsoConflictError") + + // A domain in use by the connection cannot be dropped out from under it. + const inUse = yield* sso.removeDomain(ORG, "acme.com").pipe(Effect.flip) + assert.strictEqual(inUse._tag, "@maple/http/enterprise-sso/EnterpriseSsoConflictError") + + const enforced = yield* sso.setEnforcement(ORG, true) + assert.strictEqual(enforced.connection?.enforced, true) + + const withBypass = yield* sso.addBypassUser(ORG, BREAK_GLASS) + assert.deepStrictEqual( + Arr.map(withBypass.bypassUsers, (u) => u.userId), + [BREAK_GLASS], + ) + + const created = yield* sso.createDirectory(ORG) + assert.match(created.token, /^scim_/) + assert.match(created.document.directory?.endpointUrl ?? "", /\/okta$/) + assert.isFalse(created.document.directory?.paused ?? true) + // The token is shown once: the stored row holds only Clerk's directory id. + const row = yield* Effect.promise(() => + queryFirstRow>( + testDb, + "SELECT * FROM org_sso_connections WHERE org_id = 'org_acme'", + ), + ) + assert.isFalse(Str.includes(created.token)(JSON.stringify(row))) + + const rotated = yield* sso.rotateDirectoryToken(ORG) + assert.notStrictEqual(rotated.token, created.token) + + // Groups arrive from the IdP over SCIM webhooks, then admins map them to roles. + const directoryId = [...world.clerk.directories.keys()][0] ?? "" + const applied = yield* sso.applyDirectoryGroup({ + directoryId, + groupId: "grp_admins", + displayName: "Maple Admins", + updatedAt: 1, + deleted: false, + }) + assert.strictEqual(applied, "applied") + yield* sso.applyDirectoryGroup({ + directoryId, + groupId: "grp_fin", + displayName: "Finance", + updatedAt: 1, + deleted: false, + }) + + const mapped = yield* sso.setRoleMappings(ORG, [ + { groupId: "grp_admins", role: "org:admin" }, + { groupId: "grp_fin", role: "org:analyst" }, + ]) + assert.deepStrictEqual(world.clerk.mappings.get(directoryId), [ + { groupId: "grp_admins", roleId: "role_admin" }, + { groupId: "grp_fin", roleId: "role_analyst" }, + ]) + assert.isTrue(world.clerk.directories.get(directoryId)?.group_role_mapping_enabled) + assert.deepStrictEqual( + Arr.map(mapped.roleMappings, (m) => [m.groupName, m.role]), + [ + ["Maple Admins", "org:admin"], + ["Finance", "org:analyst"], + ], + ) + assert.deepStrictEqual( + Arr.map(mapped.groups, (g) => g.displayName), + ["Finance", "Maple Admins"], + ) + + const duplicate = yield* sso + .setRoleMappings(ORG, [ + { groupId: "grp_fin", role: "org:admin" }, + { groupId: "grp_fin", role: "org:analyst" }, + ]) + .pipe(Effect.flip) + assert.strictEqual(duplicate._tag, "@maple/http/enterprise-sso/EnterpriseSsoInvalidError") + + const paused = yield* sso.setDirectoryState(ORG, true) + assert.isTrue(paused.directory?.paused) + + // Removing the connection takes the directory and its groups with it. + const removed = yield* sso.deleteConnection(ORG) + assert.isNull(removed.connection) + assert.isNull(removed.directory) + assert.deepStrictEqual(removed.groups, []) + assert.strictEqual(world.clerk.connections.size, 0) + assert.strictEqual(world.clerk.directories.size, 0) + const groupRows = yield* Effect.promise(() => + queryFirstRow<{ n: number }>( + testDb, + "SELECT count(*)::int AS n FROM org_directory_groups", + ), + ) + assert.strictEqual(groupRows?.n, 0) + }), + ) + }) + + it.effect("refuses every setup write without the Enterprise feature, but lets an org relax SSO", () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return Effect.gen(function* () { + // Set up while entitled, then the plan lapses. + yield* run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + yield* sso.setEnforcement(ORG, true) + }), + ) + world.entitled = false + yield* run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + const doc = yield* sso.get(ORG) + assert.isFalse(doc.entitled) + assert.strictEqual(doc.connection?.enforced, true) + + for (const write of [ + sso.addDomain(ORG, ADMIN, "acme.io"), + sso.createDirectory(ORG), + sso.setEnforcement(ORG, true), + ]) { + const error = yield* write.pipe(Effect.flip) + assert.strictEqual( + error._tag, + "@maple/http/enterprise-sso/EnterpriseSsoNotEntitledError", + ) + } + const relaxed = yield* sso.setEnforcement(ORG, false) + assert.strictEqual(relaxed.connection?.enforced, false) + }), + ) + }) + }) + + it.effect("passes Clerk's validation message through and leaves nothing behind", () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + world.clerk.rejectCreate = { + status: 422, + message: "The IdP metadata URL could not be fetched.", + } + const error = yield* sso + .createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + .pipe(Effect.flip) + assert.strictEqual(error._tag, "@maple/http/enterprise-sso/EnterpriseSsoInvalidError") + assert.strictEqual(error.message, "The IdP metadata URL could not be fetched.") + assert.isNull((yield* sso.get(ORG)).connection) + + const oidcWithoutSecret = yield* sso + .createConnection( + ORG, + ADMIN, + new SsoConnectionRequest({ + name: "Acme OIDC", + provider: "oidc_custom", + domains: ["acme.com"], + oidc: { + discoveryUrl: "https://id.acme.com/.well-known/openid-configuration", + clientId: "maple", + }, + }), + ) + .pipe(Effect.flip) + assert.strictEqual( + oidcWithoutSecret._tag, + "@maple/http/enterprise-sso/EnterpriseSsoInvalidError", + ) + + const notADomain = yield* sso.addDomain(ORG, ADMIN, "https://acme.com/path").pipe(Effect.flip) + assert.strictEqual(notADomain._tag, "@maple/http/enterprise-sso/EnterpriseSsoInvalidError") + }), + ) + }) + + it.effect( + "ignores directory groups for directories this region does not hold, and scopes bypass removal", + () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + const outcome = yield* sso.applyDirectoryGroup({ + directoryId: "dir_elsewhere", + groupId: "grp_1", + displayName: "Admins", + updatedAt: 1, + deleted: false, + }) + assert.strictEqual(outcome, "not_here") + + // An org with no connection has no bypass list to edit. + const exit = yield* sso.removeBypassUser(OTHER_ORG, BREAK_GLASS).pipe(Effect.exit) + assert.isTrue(Exit.isFailure(exit)) + + yield* verifiedDomain(world.dns, "acme.com") + yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + const missing = yield* sso.removeBypassUser(ORG, BREAK_GLASS).pipe(Effect.flip) + assert.strictEqual(missing._tag, "@maple/http/enterprise-sso/EnterpriseSsoNotFoundError") + }), + ) + }, + ) + + it.effect( + "scopes the instance-wide bypass list to this org's members on its domains, and clears it on delete", + () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + + // Someone else's member, even with an email on this domain, cannot be exempted from here. + const outsider = yield* sso + .addBypassUser(ORG, Schema.decodeSync(UserId)("user_outsider")) + .pipe(Effect.flip) + assert.strictEqual(outsider._tag, "@maple/http/enterprise-sso/EnterpriseSsoInvalidError") + // A member whose email is on another domain would land on another org's connection. + const contractor = yield* sso + .addBypassUser(ORG, Schema.decodeSync(UserId)("user_contractor")) + .pipe(Effect.flip) + assert.strictEqual( + contractor._tag, + "@maple/http/enterprise-sso/EnterpriseSsoInvalidError", + ) + assert.deepStrictEqual(world.clerk.bypass, []) + + yield* sso.addBypassUser(ORG, BREAK_GLASS) + assert.deepStrictEqual(world.clerk.bypass, [BREAK_GLASS]) + yield* sso.deleteConnection(ORG) + assert.deepStrictEqual(world.clerk.bypass, []) + }), + ) + }, + ) + + it.effect("lets one of two concurrent SCIM set-ups win, and drops the loser's directory", () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + const [a, b] = yield* Effect.all( + [sso.createDirectory(ORG).pipe(Effect.exit), sso.createDirectory(ORG).pipe(Effect.exit)], + { + concurrency: "unbounded", + }, + ) + assert.strictEqual(Arr.filter([a, b], Exit.isSuccess).length, 1) + assert.strictEqual(world.clerk.directories.size, 1) + }), + ) + }) + + it.effect("reads a connection deleted in Clerk as not set up, and never revives a deleted group", () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + yield* sso.createDirectory(ORG) + const directoryId = [...world.clerk.directories.keys()][0] ?? "" + const group = { directoryId, groupId: "grp_1", displayName: "Admins" } + + yield* sso.applyDirectoryGroup({ ...group, updatedAt: 10, deleted: false }) + yield* sso.applyDirectoryGroup({ ...group, updatedAt: 20, deleted: true }) + // A redelivered older update arrives after the deletion. + yield* sso.applyDirectoryGroup({ ...group, updatedAt: 15, deleted: false }) + assert.deepStrictEqual((yield* sso.get(ORG)).groups, []) + + world.clerk.directories.clear() + world.clerk.connections.clear() + const doc = yield* sso.get(ORG) + assert.isNull(doc.connection) + assert.isNull(doc.directory) + }), + ) + }) + + it.effect("refuses to exempt someone another org's SSO also covers", () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + // Another org's connection serves the user's second address. + world.clerk.connections.set("ent_partner", { + ...[...world.clerk.connections.values()][0], + id: "ent_partner", + organizationId: OTHER_ORG, + domains: ["partner.io"], + }) + const dual = yield* sso + .addBypassUser(ORG, Schema.decodeSync(UserId)("user_dual")) + .pipe(Effect.flip) + assert.strictEqual(dual._tag, "@maple/http/enterprise-sso/EnterpriseSsoInvalidError") + assert.deepStrictEqual(world.clerk.bypass, []) + }), + ) + }) + + it.effect( + "recovers from a connection or directory deleted in Clerk: domains removable, set-up repeatable", + () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + yield* sso.addDomain(ORG, ADMIN, "acme.io") + yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + yield* sso.createDirectory(ORG) + + // Directory removed in Clerk's dashboard: a new one can be set up. + world.clerk.directories.clear() + const again = yield* sso.createDirectory(ORG) + assert.isNotNull(again.document.directory) + assert.strictEqual(world.clerk.directories.size, 1) + + // Connection removed in Clerk's dashboard: domains can go, and a new IdP can connect. + world.clerk.connections.clear() + world.clerk.directories.clear() + const removed = yield* sso.removeDomain(ORG, "acme.io") + assert.deepStrictEqual( + Arr.map(removed.domains, (d) => d.domain), + ["acme.com"], + ) + const reconnected = yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + assert.isNotNull(reconnected.connection) + assert.isNull(reconnected.directory) + }), + ) + }, + ) + + it.effect("keeps a group deleted when an update arrives with the same timestamp", () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + yield* sso.createDirectory(ORG) + const directoryId = [...world.clerk.directories.keys()][0] ?? "" + const group = { directoryId, groupId: "grp_1", displayName: "Admins" } + yield* sso.applyDirectoryGroup({ ...group, updatedAt: 10, deleted: false }) + yield* sso.applyDirectoryGroup({ ...group, updatedAt: 20, deleted: true }) + yield* sso.applyDirectoryGroup({ ...group, updatedAt: 20, deleted: false }) + assert.deepStrictEqual((yield* sso.get(ORG)).groups, []) + // A genuinely newer push re-creates it. + yield* sso.applyDirectoryGroup({ ...group, updatedAt: 30, deleted: false }) + assert.deepStrictEqual( + Arr.map((yield* sso.get(ORG)).groups, (g) => g.groupId), + ["grp_1"], + ) + }), + ) + }) + + it.effect("edits a manual SAML connection without asking for the certificate again", () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + const manual = (certificate?: string) => + new SsoConnectionRequest({ + name: "Acme IdP", + provider: "saml_custom", + domains: ["acme.com"], + saml: + certificate === undefined + ? new SsoSamlSettings({ + ssoUrl: "https://idp.acme.com/sso", + entityId: "https://idp.acme.com", + }) + : new SsoSamlSettings({ + ssoUrl: "https://idp.acme.com/sso", + entityId: "https://idp.acme.com", + certificate, + }), + }) + const missing = yield* sso.createConnection(ORG, ADMIN, manual()).pipe(Effect.flip) + assert.strictEqual(missing._tag, "@maple/http/enterprise-sso/EnterpriseSsoInvalidError") + yield* sso.createConnection(ORG, ADMIN, manual("-----BEGIN CERTIFICATE-----")) + const renamed = yield* sso.updateConnection( + ORG, + new SsoConnectionRequest({ ...manual(), name: "Acme Corp IdP" }), + ) + assert.strictEqual(renamed.connection?.name, "Acme Corp IdP") + }), + ) + }) + + it.effect("never removes a break-glass entry another org's SSO also relies on", () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + yield* verifiedDomain(world.dns, "acme.com") + yield* sso.createConnection(ORG, ADMIN, samlRequest(["acme.com"])) + // Another org added the user while they were only on its domain; both now serve them. + world.clerk.bypass.push("user_dual") + world.clerk.connections.set("ent_partner", { + ...[...world.clerk.connections.values()][0], + id: "ent_partner", + organizationId: OTHER_ORG, + domains: ["partner.io"], + }) + const refused = yield* sso + .removeBypassUser(ORG, Schema.decodeSync(UserId)("user_dual")) + .pipe(Effect.flip) + assert.strictEqual(refused._tag, "@maple/http/enterprise-sso/EnterpriseSsoConflictError") + yield* sso.deleteConnection(ORG) + assert.deepStrictEqual(world.clerk.bypass, ["user_dual"]) + }), + ) + }) + + it.live( + "sweeps a deprovision only while Clerk still stands behind it, retrying a blip and then failing closed", + () => { + const testDb = createTestDb(trackedDbs) + const world = { clerk: fakeClerk(), dns: new Map>(), entitled: true } + return run( + testDb, + world, + Effect.gen(function* () { + const sso = yield* EnterpriseSsoService + assert.isTrue(yield* sso.confirmDeprovisioned(ADMIN)) + world.clerk.deprovisioned = "no" + assert.isFalse(yield* sso.confirmDeprovisioned(ADMIN)) + world.clerk.deprovisioned = "unreachable" + world.clerk.deprovisionLookups = 0 + assert.isTrue(yield* sso.confirmDeprovisioned(ADMIN)) + // One attempt and two retries before it gives up and sweeps. + assert.strictEqual(world.clerk.deprovisionLookups, 3) + }), + ) + }, + ) +}) diff --git a/packages/backend/src/services/org/enterprise-sso/EnterpriseSsoService.ts b/packages/backend/src/services/org/enterprise-sso/EnterpriseSsoService.ts new file mode 100644 index 0000000000..cc5e58f772 --- /dev/null +++ b/packages/backend/src/services/org/enterprise-sso/EnterpriseSsoService.ts @@ -0,0 +1,1256 @@ +import { customerHasFlag, ENTERPRISE_SSO_FEATURE_ID } from "@maple/domain/billing" +import { + EnterpriseSsoConflictError, + EnterpriseSsoDocument, + EnterpriseSsoInvalidError, + EnterpriseSsoNotEntitledError, + EnterpriseSsoNotFoundError, + EnterpriseSsoUnavailableError, + IsoDateTimeString, + ScimDirectoryDocument, + ScimGroupDocument, + ScimRoleMappingDocument, + ScimTokenIssued, + SSO_CHALLENGE_RECORD_PREFIX, + SsoBypassUserDocument, + SsoConnectionDocument, + SsoDomainDocument, + SsoDomainName, + SsoMappedRole, + SsoProvider, + ssoProtocolOf, + type OrgId, + type SsoConnectionRequest, + UserId, +} from "@maple/domain/http" +import * as PG from "@maple-dev/effect-orm/postgres" +import { + OrgDirectoryGroups, + OrgSsoConnections, + OrgSsoDomains, + type OrgSsoConnectionRow, + type OrgSsoDomainRow, +} from "@maple/db/tables" +import { EdgeCacheService } from "@maple/cache" +import { + Array as Arr, + Clock, + Context, + Duration, + Effect, + Layer, + Option, + Order, + Schedule, + Schema, + String as Str, +} from "effect" +import * as SecureRandom from "effect/crypto/SecureRandom" +import * as Hex from "effect/encoding/Hex" +import { Database } from "@maple/backend/platform/DatabaseLive" +import { makeDbExecute, makePersistenceErrorMapper } from "@maple/backend/platform/db-execute" +import type { ClerkRequestError } from "@maple/backend/services/auth/clerk-request" +import { BillingCustomerResolver } from "@maple/backend/services/billing/BillingCustomerResolver" +import { ensureOk, readCustomerCached } from "@maple/backend/services/billing/autumn-client" +import { AutumnClient } from "@maple/backend/services/billing/autumn-http" +import { + ClerkSsoGateway, + type ClerkSsoConnection, + type ClerkSsoConnectionInput, + type ClerkSsoDirectory, +} from "./ClerkSsoGateway" +import { DnsTxtResolver } from "./DnsTxtResolver" + +type Entitlement = "entitled" | "not_entitled" | "unknown" + +export type SsoWriteError = + | EnterpriseSsoUnavailableError + | EnterpriseSsoNotEntitledError + | EnterpriseSsoInvalidError + | EnterpriseSsoConflictError + | EnterpriseSsoNotFoundError + +const decodeIso = Schema.decodeUnknownSync(IsoDateTimeString) +const iso = (ms: number) => decodeIso(new Date(ms).toISOString()) +const isDomainName = Schema.is(SsoDomainName) +const isMappedRole = Schema.is(SsoMappedRole) +const isProvider = Schema.is(SsoProvider) +const decodeUserId = Schema.decodeSync(UserId) +const byDomain = Order.mapInput(Str.Order, (d: SsoDomainDocument) => d.domain) +const byGroupName = Order.mapInput(Str.Order, (g: ScimGroupDocument) => g.displayName) + +/** A Clerk object deleted out from under Maple reads as missing, not as an outage. */ +const orMissing = (effect: Effect.Effect) => + effect.pipe( + Effect.asSome, + Effect.catchIf( + (e) => e.status === 404, + () => Effect.succeed(Option.none()), + ), + ) +const orEmpty = (effect: Effect.Effect, ClerkRequestError>) => + effect.pipe( + Effect.catchIf( + (e) => e.status === 404, + () => Effect.succeed>([]), + ), + ) + +/** Best-effort undo of a Clerk object Maple failed to record; a failure is logged, never raised. */ +const undo = (what: string, effect: Effect.Effect) => + effect.pipe( + Effect.tapError((error) => + Effect.logError(`Could not undo the Clerk ${what} Maple failed to record`).pipe( + Effect.annotateLogs({ operation: error.operation, error: error.message }), + ), + ), + Effect.ignore, + ) + +const toPersistenceError = makePersistenceErrorMapper( + EnterpriseSsoUnavailableError, + "SSO settings persistence failure", +) + +/** Lower-cased, trimmed, no trailing dot, so `Acme.com.` and `acme.com` are one domain. */ +export const normalizeDomain = (raw: string): string => Str.replace(/\.$/, "")(Str.toLowerCase(Str.trim(raw))) + +export const challengeRecordName = (domain: string) => `${SSO_CHALLENGE_RECORD_PREFIX}.${domain}` + +/** Clerk's typed failure as what the settings page can act on; Clerk's 4xx text is user-facing. */ +const fromClerk = (error: ClerkRequestError): SsoWriteError => { + switch (error.status) { + case 400: + case 422: + return new EnterpriseSsoInvalidError({ message: error.message }) + case 409: + return new EnterpriseSsoConflictError({ message: error.message }) + case 404: + return new EnterpriseSsoNotFoundError({ message: error.message }) + default: + return new EnterpriseSsoUnavailableError({ message: `${error.operation}: ${error.message}` }) + } +} + +const unavailable = (error: ClerkRequestError) => + new EnterpriseSsoUnavailableError({ message: `${error.operation}: ${error.message}` }) + +/** Okta and Entra get Clerk's guided SCIM flavour; everything else pushes as a custom SCIM 2.0 client. */ +const directoryProviderFor = (provider: string): "okta" | "entra" | "custom" => + provider === "saml_okta" ? "okta" : provider === "saml_microsoft" ? "entra" : "custom" + +export interface DirectoryGroupEvent { + readonly directoryId: string + readonly groupId: string + readonly displayName: string + readonly updatedAt: number + readonly deleted: boolean +} + +export interface EnterpriseSsoServiceApi { + readonly get: (orgId: OrgId) => Effect.Effect + readonly addDomain: ( + orgId: OrgId, + userId: UserId, + domain: string, + ) => Effect.Effect + readonly verifyDomain: ( + orgId: OrgId, + domain: string, + ) => Effect.Effect + readonly removeDomain: ( + orgId: OrgId, + domain: string, + ) => Effect.Effect + readonly createConnection: ( + orgId: OrgId, + userId: UserId, + request: SsoConnectionRequest, + ) => Effect.Effect + readonly updateConnection: ( + orgId: OrgId, + request: SsoConnectionRequest, + ) => Effect.Effect + readonly setEnforcement: ( + orgId: OrgId, + enforced: boolean, + ) => Effect.Effect + readonly deleteConnection: (orgId: OrgId) => Effect.Effect + readonly createDirectory: (orgId: OrgId) => Effect.Effect + readonly rotateDirectoryToken: (orgId: OrgId) => Effect.Effect + readonly setDirectoryState: ( + orgId: OrgId, + paused: boolean, + ) => Effect.Effect + readonly deleteDirectory: (orgId: OrgId) => Effect.Effect + readonly setRoleMappings: ( + orgId: OrgId, + mappings: ReadonlyArray<{ readonly groupId: string; readonly role: SsoMappedRole }>, + ) => Effect.Effect + readonly addBypassUser: ( + orgId: OrgId, + userId: UserId, + ) => Effect.Effect + readonly removeBypassUser: ( + orgId: OrgId, + userId: UserId, + ) => Effect.Effect + /** + * Applies a `directoryGroup.*` webhook. `not_here` when no org in this region owns the directory: + * each region receives every event and only the home region holds the row. + */ + readonly applyDirectoryGroup: ( + event: DirectoryGroupEvent, + ) => Effect.Effect<"applied" | "not_here", EnterpriseSsoUnavailableError> + /** + * Whether Clerk still holds the user deprovisioned, asked before a `deprovisioned` webhook + * sweeps: deliveries are unordered, so an old one must not revoke keys made after reactivation. + * Fails closed: an unanswered lookup or a deleted user reads as deprovisioned. + */ + readonly confirmDeprovisioned: (userId: UserId) => Effect.Effect +} + +export class EnterpriseSsoService extends Context.Service()( + "@maple/backend/services/org/enterprise-sso/EnterpriseSsoService", + { + make: Effect.gen(function* () { + const database = yield* Database + const edgeCache = yield* EdgeCacheService + const autumn = yield* AutumnClient + const billingCustomers = yield* BillingCustomerResolver + const clerk = yield* ClerkSsoGateway + const dns = yield* DnsTxtResolver + const dbExecute = makeDbExecute(database, "EnterpriseSsoService", toPersistenceError) + + // Billing that is not configured (self-hosted, local dev) sells nothing: everything is on. + const entitlement = (orgId: OrgId): Effect.Effect => + billingCustomers.customerFor(orgId).pipe( + Effect.flatMap((customerId) => + readCustomerCached( + edgeCache, + customerId, + autumn.getOrCreateCustomer(customerId, { expand: ["subscriptions.plan"] }), + ), + ), + Effect.flatMap(({ result }) => ensureOk(result)), + Effect.map((customer): Entitlement => + customerHasFlag(customer, ENTERPRISE_SSO_FEATURE_ID) ? "entitled" : "not_entitled", + ), + Effect.catchTags({ + "@maple/http/errors/BillingNotConfiguredError": () => + Effect.succeed("entitled"), + "@maple/http/errors/BillingUpstreamError": (error) => + Effect.logWarning("Could not read the enterprise SSO entitlement").pipe( + Effect.annotateLogs({ orgId, error: error.message }), + Effect.as("unknown"), + ), + "@maple/http/errors/BillingAccountPersistenceError": (error) => + Effect.logWarning("Could not read the enterprise SSO entitlement").pipe( + Effect.annotateLogs({ orgId, error: error.message }), + Effect.as("unknown"), + ), + }), + ) + + /** Every write starts here: Clerk mode, and the org holds `enterprise_sso`. */ + const requireEntitled = Effect.fn("EnterpriseSsoService.requireEntitled")(function* ( + orgId: OrgId, + ) { + if (!clerk.available) { + return yield* new EnterpriseSsoInvalidError({ + message: + "Single sign-on needs Maple's hosted sign-in; this deployment runs without it.", + }) + } + const state = yield* entitlement(orgId) + if (state === "not_entitled") { + return yield* new EnterpriseSsoNotEntitledError({ + message: + "SSO and SCIM provisioning are part of the Enterprise plan. Contact sales to enable them.", + }) + } + if (state === "unknown") { + return yield* new EnterpriseSsoUnavailableError({ + message: "Could not confirm the plan with billing.", + }) + } + }) + + const loadDomains = (orgId: OrgId) => + dbExecute((db) => + db.run( + PG.from(OrgSsoDomains) + .select() + .where(($) => [$.orgId.eq(orgId)]), + ), + ) + + const loadConnectionRow = (orgId: OrgId) => + dbExecute((db) => + db.run( + PG.from(OrgSsoConnections) + .select() + .where(($) => [$.orgId.eq(orgId)]) + .limit(1), + ), + ).pipe(Effect.map((rows) => Option.fromUndefinedOr(rows[0]))) + + const requireConnectionRow = (orgId: OrgId) => + loadConnectionRow(orgId).pipe( + Effect.flatMap( + Option.match({ + onNone: () => + Effect.fail( + new EnterpriseSsoNotFoundError({ + message: "Connect an identity provider first.", + }), + ), + onSome: Effect.succeed, + }), + ), + ) + + const requireDirectoryId = (row: OrgSsoConnectionRow) => + row.clerkDirectoryId === null + ? Effect.fail( + new EnterpriseSsoNotFoundError({ message: "Set up SCIM provisioning first." }), + ) + : Effect.succeed(row.clerkDirectoryId) + + const toDomainDocument = (row: OrgSsoDomainRow) => + new SsoDomainDocument({ + domain: row.domain, + status: row.status, + recordName: challengeRecordName(row.domain), + recordValue: row.challenge, + verifiedAt: row.verifiedAt === null ? null : iso(row.verifiedAt), + }) + + const toConnectionDocument = (c: ClerkSsoConnection) => { + const provider = isProvider(c.provider) ? c.provider : "saml_custom" + return new SsoConnectionDocument({ + name: c.name, + provider, + protocol: ssoProtocolOf(provider), + domains: c.domains, + enforced: c.active, + acsUrl: c.saml?.acsUrl ?? null, + spEntityId: c.saml?.spEntityId ?? null, + spMetadataUrl: c.saml?.spMetadataUrl ?? null, + idpMetadataUrl: c.saml?.idpMetadataUrl ?? null, + idpSsoUrl: c.saml?.idpSsoUrl ?? null, + idpEntityId: c.saml?.idpEntityId ?? null, + idpCertificateExpiresAt: + c.saml?.certificateExpiresAt === null || c.saml?.certificateExpiresAt === undefined + ? null + : iso(c.saml.certificateExpiresAt), + oidcDiscoveryUrl: c.oidc?.discoveryUrl ?? null, + oidcClientId: c.oidc?.clientId ?? null, + createdAt: iso(c.createdAt), + }) + } + + const toDirectoryDocument = (d: ClerkSsoDirectory) => + new ScimDirectoryDocument({ + endpointUrl: d.endpoint_url, + enabled: d.enabled, + paused: d.paused, + createdAt: iso(d.created_at), + }) + + const get = Effect.fn("EnterpriseSsoService.get")(function* (orgId: OrgId) { + yield* Effect.annotateCurrentSpan({ orgId }) + const [domains, row, entitled] = yield* Effect.all( + [loadDomains(orgId), loadConnectionRow(orgId), entitlement(orgId)], + { concurrency: "unbounded" }, + ) + const empty = { + connection: null, + directory: null, + roleMappings: [], + groups: [], + bypassUsers: [], + } + const clerkSide = Option.isNone(row) + ? Effect.succeed(empty) + : Effect.gen(function* () { + const { clerkConnectionId, clerkDirectoryId } = row.value + const [connection, directory, mappings, bypass, groups] = yield* Effect.all( + [ + orMissing(clerk.getConnection(clerkConnectionId)), + clerkDirectoryId === null + ? Effect.succeed(Option.none()) + : orMissing(clerk.getDirectory(clerkDirectoryId)), + clerkDirectoryId === null + ? Effect.succeed([]) + : clerk.listRoleMappings(clerkDirectoryId).pipe(orEmpty), + clerk.listBypassUsers(clerkConnectionId).pipe(orEmpty), + clerkDirectoryId === null + ? Effect.succeed([]) + : dbExecute((db) => + db.run( + PG.from(OrgDirectoryGroups) + .select() + .where(($) => [ + $.orgId.eq(orgId), + $.directoryId.eq(clerkDirectoryId), + $.deletedAt.isNull(), + ]), + ), + ), + ], + { concurrency: "unbounded" }, + ).pipe( + Effect.catchTag("@maple/backend/services/auth/ClerkRequestError", (e) => + Effect.fail(unavailable(e)), + ), + ) + // Removed in Clerk's dashboard or a half-finished delete: show it as not set up. + if (Option.isNone(connection)) return empty + const names = new Map(Arr.map(groups, (g) => [g.groupId, g.displayName] as const)) + return { + connection: toConnectionDocument(connection.value), + directory: Option.match(directory, { + onNone: () => null, + onSome: toDirectoryDocument, + }), + roleMappings: Arr.flatMap(mappings, (m) => + isMappedRole(m.roleKey) + ? [ + new ScimRoleMappingDocument({ + groupId: m.groupId, + groupName: m.groupName ?? names.get(m.groupId) ?? null, + role: m.roleKey, + }), + ] + : [], + ), + groups: Arr.sort( + Arr.map( + groups, + (g) => + new ScimGroupDocument({ + groupId: g.groupId, + displayName: g.displayName, + }), + ), + byGroupName, + ), + bypassUsers: Arr.map( + bypass, + (u) => + new SsoBypassUserDocument({ + userId: decodeUserId(u.userId), + identifier: u.identifier, + }), + ), + } + }) + const side = yield* clerkSide + return new EnterpriseSsoDocument({ + // An outage reads as entitled: the page should not flash an upsell at a paying org. + entitled: entitled !== "not_entitled", + domains: Arr.sort(Arr.map(domains, toDomainDocument), byDomain), + ...side, + }) + }) + + const addDomain = Effect.fn("EnterpriseSsoService.addDomain")(function* ( + orgId: OrgId, + userId: UserId, + raw: string, + ) { + yield* requireEntitled(orgId) + const domain = normalizeDomain(raw) + yield* Effect.annotateCurrentSpan({ orgId, "maple.sso.domain": domain }) + if (!isDomainName(domain)) { + return yield* new EnterpriseSsoInvalidError({ + message: `"${raw}" is not a domain name, e.g. acme.com.`, + }) + } + const now = yield* Clock.currentTimeMillis + const bytes = yield* Effect.sync(() => SecureRandom.randomBytesUnsafe(16)) + const challenge = `maple-domain-verification=${Hex.encode(bytes)}` + yield* dbExecute((db) => + db.run( + PG.insertInto(OrgSsoDomains) + .values({ + orgId, + domain, + challenge, + status: "pending", + clerkDomainId: null, + verifiedAt: null, + createdAt: now, + createdBy: userId, + }) + .onConflictDoNothing(), + ), + ) + return yield* get(orgId) + }) + + const requireDomainRow = (orgId: OrgId, domain: string) => + loadDomains(orgId).pipe( + Effect.flatMap((rows) => { + const row = Option.getOrUndefined(Arr.findFirst(rows, (r) => r.domain === domain)) + return row === undefined + ? Effect.fail( + new EnterpriseSsoNotFoundError({ + message: `${domain} is not one of this organization's SSO domains.`, + }), + ) + : Effect.succeed(row) + }), + ) + + const verifyDomain = Effect.fn("EnterpriseSsoService.verifyDomain")(function* ( + orgId: OrgId, + raw: string, + ) { + yield* requireEntitled(orgId) + const domain = normalizeDomain(raw) + yield* Effect.annotateCurrentSpan({ orgId, "maple.sso.domain": domain }) + const row = yield* requireDomainRow(orgId, domain) + if (row.status === "verified") return yield* get(orgId) + const values = yield* dns.lookupTxt(challengeRecordName(domain)).pipe( + Effect.mapError( + (error) => + new EnterpriseSsoUnavailableError({ + message: `DNS lookup failed: ${error.message}`, + }), + ), + ) + yield* Effect.annotateCurrentSpan({ "maple.sso.txt_records": values.length }) + if (!values.includes(row.challenge)) { + return yield* new EnterpriseSsoInvalidError({ + message: `No matching TXT record at ${challengeRecordName(domain)} yet. DNS changes can take a few minutes to appear.`, + }) + } + const clerkDomainId = yield* clerk + .ensureOrgDomain(orgId, domain) + .pipe(Effect.mapError(fromClerk)) + yield* clerk.verifyOrgDomainOwnership(orgId, clerkDomainId).pipe(Effect.mapError(fromClerk)) + const now = yield* Clock.currentTimeMillis + yield* dbExecute((db) => + db.run( + PG.update(OrgSsoDomains) + .set({ status: "verified", clerkDomainId, verifiedAt: now }) + .where(($) => [$.orgId.eq(orgId), $.domain.eq(domain)]), + ), + ) + return yield* get(orgId) + }) + + const removeDomain = Effect.fn("EnterpriseSsoService.removeDomain")(function* ( + orgId: OrgId, + raw: string, + ) { + const domain = normalizeDomain(raw) + yield* Effect.annotateCurrentSpan({ orgId, "maple.sso.domain": domain }) + yield* requireDomainRow(orgId, domain) + const row = yield* loadConnectionRow(orgId) + if (Option.isSome(row)) { + const connection = yield* orMissing( + clerk.getConnection(row.value.clerkConnectionId), + ).pipe(Effect.mapError(fromClerk)) + // A connection already gone in Clerk holds no domain. + if (Option.isSome(connection) && Arr.contains(connection.value.domains, domain)) { + return yield* new EnterpriseSsoConflictError({ + message: `${domain} is used by the identity provider connection. Remove it there first.`, + }) + } + } + // The Clerk organization domain stays: the Domains tab owns it and may use it for invitations. + yield* dbExecute((db) => + db.run( + PG.deleteFrom(OrgSsoDomains).where(($) => [$.orgId.eq(orgId), $.domain.eq(domain)]), + ), + ) + return yield* get(orgId) + }) + + /** The request's domains, all verified by this org, and the IdP settings its protocol needs. */ + const connectionInput = Effect.fn("EnterpriseSsoService.connectionInput")(function* ( + orgId: OrgId, + request: SsoConnectionRequest, + provider: SsoProvider, + mode: "create" | "update", + ) { + const domains = Arr.dedupe(Arr.map(request.domains, normalizeDomain)) + const rows = yield* loadDomains(orgId) + const verified = new Set( + Arr.map( + Arr.filter(rows, (d) => d.status === "verified"), + (d) => d.domain, + ), + ) + const unverified = Arr.filter(domains, (d) => !verified.has(d)) + if (unverified.length > 0) { + return yield* new EnterpriseSsoInvalidError({ + message: `Verify ${Arr.join(unverified, ", ")} before using it for SSO.`, + }) + } + const base = { name: Str.trim(request.name), domains } + if (ssoProtocolOf(provider) === "saml") { + const saml = request.saml + // On an edit an omitted certificate keeps the one Clerk holds; a new connection needs it. + const manual = + saml?.ssoUrl !== undefined && + saml.entityId !== undefined && + (saml.certificate !== undefined || mode === "update") + if (saml === undefined || (saml.metadataUrl === undefined && !manual)) { + if (mode === "update" && saml === undefined) + return base satisfies ClerkSsoConnectionInput + return yield* new EnterpriseSsoInvalidError({ + message: + "Give the IdP metadata URL, or its SSO URL, entity ID and signing certificate.", + }) + } + return { ...base, saml } satisfies ClerkSsoConnectionInput + } else { + const oidc = request.oidc + if (oidc === undefined) { + if (mode === "update") return base satisfies ClerkSsoConnectionInput + return yield* new EnterpriseSsoInvalidError({ + message: "Give the OIDC discovery URL, client ID and client secret.", + }) + } + if (mode === "create" && (oidc.clientSecret === undefined || oidc.clientSecret === "")) { + return yield* new EnterpriseSsoInvalidError({ + message: "Give the OIDC client secret.", + }) + } + return { ...base, oidc } satisfies ClerkSsoConnectionInput + } + }) + + const createConnection = Effect.fn("EnterpriseSsoService.createConnection")(function* ( + orgId: OrgId, + userId: UserId, + request: SsoConnectionRequest, + ) { + yield* requireEntitled(orgId) + yield* Effect.annotateCurrentSpan({ orgId, "maple.sso.provider": request.provider }) + const existing = yield* reconcileRow(orgId) + if (Option.isSome(existing)) { + return yield* new EnterpriseSsoConflictError({ + message: "This organization already has an identity provider connected.", + }) + } + const input = yield* connectionInput(orgId, request, request.provider, "create") + // Uninterruptible so a dropped request cannot strand a Clerk connection Maple never saved: + // one Maple cannot find again would claim the domains forever. + yield* Effect.uninterruptible( + Effect.gen(function* () { + const connection = yield* clerk + .createConnection(orgId, request.provider, input) + .pipe(Effect.mapError(fromClerk)) + const now = yield* Clock.currentTimeMillis + yield* dbExecute((db) => + db.run( + PG.insertInto(OrgSsoConnections).values({ + orgId, + clerkConnectionId: connection.id, + clerkDirectoryId: null, + createdAt: now, + createdBy: userId, + updatedAt: now, + }), + ), + ).pipe( + Effect.onError(() => undo("connection", clerk.deleteConnection(connection.id))), + ) + }), + ) + return yield* get(orgId) + }) + + const updateConnection = Effect.fn("EnterpriseSsoService.updateConnection")(function* ( + orgId: OrgId, + request: SsoConnectionRequest, + ) { + yield* requireEntitled(orgId) + const row = yield* requireConnectionRow(orgId) + const current = yield* clerk + .getConnection(row.clerkConnectionId) + .pipe(Effect.mapError(fromClerk)) + const provider = isProvider(current.provider) ? current.provider : request.provider + const input = yield* connectionInput(orgId, request, provider, "update") + yield* clerk.updateConnection(row.clerkConnectionId, input).pipe(Effect.mapError(fromClerk)) + yield* touch(orgId) + return yield* get(orgId) + }) + + const touch = (orgId: OrgId, set: { clerkDirectoryId?: string | null } = {}) => + Clock.currentTimeMillis.pipe( + Effect.flatMap((now) => + dbExecute((db) => + db.run( + PG.update(OrgSsoConnections) + .set({ updatedAt: now, ...set }) + .where(($) => [$.orgId.eq(orgId)]), + ), + ), + ), + ) + + const setEnforcement = Effect.fn("EnterpriseSsoService.setEnforcement")(function* ( + orgId: OrgId, + enforced: boolean, + ) { + // Relaxing is always allowed: an org that lost the plan must still be able to get out. + if (enforced) yield* requireEntitled(orgId) + yield* Effect.annotateCurrentSpan({ orgId, "maple.sso.enforced": enforced }) + const row = yield* requireConnectionRow(orgId) + yield* clerk + .updateConnection(row.clerkConnectionId, { active: enforced }) + .pipe(Effect.mapError(fromClerk)) + yield* touch(orgId) + return yield* get(orgId) + }) + + const clearDirectory = (orgId: OrgId, directoryId: string) => + Clock.currentTimeMillis.pipe( + Effect.flatMap((now) => + dbExecute((db) => + db.run( + PG.update(OrgSsoConnections) + .set({ clerkDirectoryId: null, updatedAt: now }) + .where(($) => [$.orgId.eq(orgId), $.clerkDirectoryId.eq(directoryId)]), + ), + ), + ), + ) + + /** + * The org's row with ids Clerk has confirmed deleted (404) cleared, so a connection or + * directory removed in Clerk's dashboard does not block setting up a new one. + */ + const reconcileRow = Effect.fn("EnterpriseSsoService.reconcileRow")(function* (orgId: OrgId) { + const row = yield* loadConnectionRow(orgId) + if (Option.isNone(row)) return Option.none() + const { clerkConnectionId, clerkDirectoryId } = row.value + const [connection, directory] = yield* Effect.all( + [ + orMissing(clerk.getConnection(clerkConnectionId)), + clerkDirectoryId === null + ? Effect.succeedSome(null) + : orMissing(clerk.getDirectory(clerkDirectoryId)), + ], + { concurrency: "unbounded" }, + ).pipe(Effect.mapError(fromClerk)) + const dropGroups = (directoryId: string) => + dbExecute((db) => + db.run( + PG.deleteFrom(OrgDirectoryGroups).where(($) => [ + $.orgId.eq(orgId), + $.directoryId.eq(directoryId), + ]), + ), + ) + if (Option.isNone(connection)) { + yield* Effect.annotateCurrentSpan({ "maple.sso.reconciled": "connection" }) + yield* dbExecute((db) => + db.run( + PG.deleteFrom(OrgSsoConnections).where(($) => [ + $.orgId.eq(orgId), + $.clerkConnectionId.eq(clerkConnectionId), + ]), + ), + ) + if (clerkDirectoryId !== null) yield* dropGroups(clerkDirectoryId) + return Option.none() + } + if (clerkDirectoryId !== null && Option.isNone(directory)) { + yield* Effect.annotateCurrentSpan({ "maple.sso.reconciled": "directory" }) + yield* clearDirectory(orgId, clerkDirectoryId) + yield* dropGroups(clerkDirectoryId) + return Option.some({ ...row.value, clerkDirectoryId: null }) + } + return row + }) + + /** Clerk first, then the row and groups, so the row never points at a deleted directory. */ + const dropDirectory = (orgId: OrgId, directoryId: string) => + clerk.deleteDirectory(directoryId).pipe( + Effect.catchIf( + (e) => e.status === 404, + () => Effect.void, + ), + Effect.mapError(fromClerk), + // Only this directory's binding: a slower, overlapping delete must not clear a newer one. + Effect.andThen(clearDirectory(orgId, directoryId)), + Effect.andThen( + dbExecute((db) => + db.run( + PG.deleteFrom(OrgDirectoryGroups).where(($) => [ + $.orgId.eq(orgId), + $.directoryId.eq(directoryId), + ]), + ), + ), + ), + ) + + const deleteConnection = Effect.fn("EnterpriseSsoService.deleteConnection")(function* ( + orgId: OrgId, + ) { + yield* Effect.annotateCurrentSpan({ orgId }) + const row = yield* requireConnectionRow(orgId) + // Bypass entries are instance-wide and would outlive the connection that justified them. + const bypass = yield* clerk + .listBypassUsers(row.clerkConnectionId) + .pipe(orEmpty, Effect.mapError(fromClerk)) + const ownDomains = yield* orMissing(clerk.getConnection(row.clerkConnectionId)).pipe( + Effect.mapBoth({ + onSuccess: Option.match({ onNone: () => [], onSome: (c) => c.domains }), + onFailure: fromClerk, + }), + ) + yield* Effect.forEach( + bypass, + (u) => + Effect.gen(function* () { + const userId = decodeUserId(u.userId) + // Another org's SSO also covers them: its entry is the same one, so it stays. + const elsewhere = yield* coveredElsewhere( + userId, + row.clerkConnectionId, + ownDomains, + ) + if (elsewhere.length > 0) { + return yield* Effect.logWarning( + "Kept a bypass entry another org's SSO also serves", + ).pipe(Effect.annotateLogs({ orgId, userId })) + } + yield* clerk.removeBypassUser(userId).pipe( + Effect.catchIf( + (e) => e.status === 404, + () => Effect.void, + ), + ) + }).pipe(Effect.mapError(fromClerk)), + { concurrency: 4, discard: true }, + ) + if (row.clerkDirectoryId !== null) yield* dropDirectory(orgId, row.clerkDirectoryId) + yield* clerk.deleteConnection(row.clerkConnectionId).pipe( + Effect.catchIf( + (e) => e.status === 404, + () => Effect.void, + ), + Effect.mapError(fromClerk), + ) + yield* dbExecute((db) => + db.run( + PG.deleteFrom(OrgSsoConnections).where(($) => [ + $.orgId.eq(orgId), + $.clerkConnectionId.eq(row.clerkConnectionId), + ]), + ), + ) + return yield* get(orgId) + }) + + const issued = (orgId: OrgId, directory: ClerkSsoDirectory) => + Effect.gen(function* () { + const token = directory.api_key + if (token === undefined || token === null || token === "") { + return yield* new EnterpriseSsoUnavailableError({ + message: "Clerk returned no SCIM token", + }) + } + // The token exists only in this response, so a failed refresh must not swallow it. + const document = yield* get(orgId).pipe( + Effect.catch((error) => + Effect.logWarning("SSO document refresh failed after issuing a SCIM token").pipe( + Effect.annotateLogs({ orgId, error: error.message }), + Effect.andThen(loadDomains(orgId)), + Effect.map( + (domains) => + new EnterpriseSsoDocument({ + entitled: true, + domains: Arr.sort(Arr.map(domains, toDomainDocument), byDomain), + connection: null, + directory: toDirectoryDocument(directory), + roleMappings: [], + groups: [], + bypassUsers: [], + }), + ), + Effect.orElseSucceed( + () => + new EnterpriseSsoDocument({ + entitled: true, + domains: [], + connection: null, + directory: toDirectoryDocument(directory), + roleMappings: [], + groups: [], + bypassUsers: [], + }), + ), + ), + ), + ) + return new ScimTokenIssued({ document, token }) + }) + + const createDirectory = Effect.fn("EnterpriseSsoService.createDirectory")(function* ( + orgId: OrgId, + ) { + yield* requireEntitled(orgId) + yield* Effect.annotateCurrentSpan({ orgId }) + const reconciled = yield* reconcileRow(orgId) + if (Option.isNone(reconciled)) { + return yield* new EnterpriseSsoNotFoundError({ + message: "Connect an identity provider first.", + }) + } + const row = reconciled.value + if (row.clerkDirectoryId !== null) { + return yield* new EnterpriseSsoConflictError({ + message: "SCIM provisioning is already set up. Rotate its token to get a new one.", + }) + } + const connection = yield* clerk + .getConnection(row.clerkConnectionId) + .pipe(Effect.mapError(fromClerk)) + const directory = yield* Effect.uninterruptible( + Effect.gen(function* () { + const created = yield* clerk + .createDirectory(row.clerkConnectionId, directoryProviderFor(connection.provider)) + .pipe(Effect.mapError(fromClerk)) + const dropCreated = undo("directory", clerk.deleteDirectory(created.id)) + const now = yield* Clock.currentTimeMillis + // Claims the slot only if still empty: of two concurrent set-ups, one wins. + const claimed = yield* dbExecute((db) => + db.run( + PG.update(OrgSsoConnections) + .set({ clerkDirectoryId: created.id, updatedAt: now }) + .where(($) => [ + $.orgId.eq(orgId), + // The connection it was made for: a replaced connection must not inherit it. + $.clerkConnectionId.eq(row.clerkConnectionId), + $.clerkDirectoryId.isNull(), + ]) + .returning("orgId"), + ), + ).pipe(Effect.onError(() => dropCreated)) + if (claimed.length === 0) { + yield* dropCreated + return yield* new EnterpriseSsoConflictError({ + message: + "SCIM provisioning is already set up. Rotate its token to get a new one.", + }) + } + return created + }), + ) + return yield* issued(orgId, directory) + }) + + const rotateDirectoryToken = Effect.fn("EnterpriseSsoService.rotateDirectoryToken")(function* ( + orgId: OrgId, + ) { + yield* requireEntitled(orgId) + yield* Effect.annotateCurrentSpan({ orgId }) + const directoryId = yield* requireConnectionRow(orgId).pipe( + Effect.flatMap(requireDirectoryId), + ) + const directory = yield* clerk + .rotateDirectoryKey(directoryId) + .pipe(Effect.mapError(fromClerk)) + // The old key is already retiring: a failed timestamp write must not swallow the new one. + yield* touch(orgId).pipe( + Effect.catch((error) => + Effect.logWarning("SSO timestamp update failed after rotating a SCIM token").pipe( + Effect.annotateLogs({ orgId, error: error.message }), + ), + ), + ) + return yield* issued(orgId, directory) + }) + + const setDirectoryState = Effect.fn("EnterpriseSsoService.setDirectoryState")(function* ( + orgId: OrgId, + paused: boolean, + ) { + if (!paused) yield* requireEntitled(orgId) + yield* Effect.annotateCurrentSpan({ orgId, "maple.sso.directory_paused": paused }) + const directoryId = yield* requireConnectionRow(orgId).pipe( + Effect.flatMap(requireDirectoryId), + ) + yield* clerk.updateDirectory(directoryId, { paused }).pipe(Effect.mapError(fromClerk)) + yield* touch(orgId) + return yield* get(orgId) + }) + + const deleteDirectory = Effect.fn("EnterpriseSsoService.deleteDirectory")(function* ( + orgId: OrgId, + ) { + yield* Effect.annotateCurrentSpan({ orgId }) + const directoryId = yield* requireConnectionRow(orgId).pipe( + Effect.flatMap(requireDirectoryId), + ) + yield* dropDirectory(orgId, directoryId) + return yield* get(orgId) + }) + + const setRoleMappings = Effect.fn("EnterpriseSsoService.setRoleMappings")(function* ( + orgId: OrgId, + mappings: ReadonlyArray<{ readonly groupId: string; readonly role: SsoMappedRole }>, + ) { + yield* requireEntitled(orgId) + yield* Effect.annotateCurrentSpan({ orgId, "maple.sso.role_mappings": mappings.length }) + const directoryId = yield* requireConnectionRow(orgId).pipe( + Effect.flatMap(requireDirectoryId), + ) + const groupIds = Arr.map(mappings, (m) => m.groupId) + if (new Set(groupIds).size !== groupIds.length) { + return yield* new EnterpriseSsoInvalidError({ + message: "Map each group to one role only.", + }) + } + const roles = yield* clerk.listRoles.pipe(Effect.mapError(fromClerk)) + const roleIds = new Map(Arr.map(roles, (r) => [r.key, r.id] as const)) + const resolved = yield* Effect.forEach(mappings, (m) => { + const roleId = roleIds.get(m.role) + return roleId === undefined + ? Effect.fail( + new EnterpriseSsoInvalidError({ + message: `The ${m.role} role does not exist in this deployment.`, + }), + ) + : Effect.succeed({ groupId: m.groupId, roleId }) + }) + yield* clerk.replaceRoleMappings(directoryId, resolved).pipe(Effect.mapError(fromClerk)) + // Clerk applies a mapping when the IdP next pushes the group, not on save (seen live): + // existing members change role on the IdP's next sync. + yield* clerk + .updateDirectory(directoryId, { group_role_mapping_enabled: true }) + .pipe(Effect.mapError(fromClerk)) + yield* touch(orgId) + return yield* get(orgId) + }) + + /** + * The user's verified email domains another org's connection serves. Clerk's bypass entry + * is per user across every connection serving them, so adding or removing one for such a + * user would also change that other org's SSO. + */ + const coveredElsewhere = ( + userId: UserId, + connectionId: string, + ownDomains: ReadonlyArray, + ) => + clerk.verifiedEmailDomains(userId).pipe( + Effect.flatMap((domains) => + clerk.domainsClaimedElsewhere( + connectionId, + Arr.filter(domains, (d) => !Arr.contains(ownDomains, d)), + ), + ), + ) + + const addBypassUser = Effect.fn("EnterpriseSsoService.addBypassUser")(function* ( + orgId: OrgId, + userId: UserId, + ) { + yield* requireEntitled(orgId) + yield* Effect.annotateCurrentSpan({ orgId, "maple.sso.bypass_user": userId }) + const row = yield* requireConnectionRow(orgId) + // The allowlist is instance-wide, so Maple scopes it: a member of this org with a + // verified email on this connection's domains, so the entry serves only this org. + const [connection, member, emailDomains] = yield* Effect.all( + [ + clerk.getConnection(row.clerkConnectionId), + clerk.isMember(orgId, userId), + clerk.verifiedEmailDomains(userId), + ], + { concurrency: "unbounded" }, + ).pipe(Effect.mapError(fromClerk)) + if (!member) { + return yield* new EnterpriseSsoInvalidError({ + message: "Only members of this organization can be added.", + }) + } + if (!Arr.some(emailDomains, (d) => Arr.contains(connection.domains, d))) { + return yield* new EnterpriseSsoInvalidError({ + message: `Only people with a verified email on ${Arr.join(connection.domains, ", ")} can bypass SSO.`, + }) + } + // Clerk's entry exempts the user from every connection that serves them, so a user + // another org's SSO also covers cannot be exempted from here. + const elsewhere = yield* clerk + .domainsClaimedElsewhere( + row.clerkConnectionId, + Arr.filter(emailDomains, (d) => !Arr.contains(connection.domains, d)), + ) + .pipe(Effect.mapError(fromClerk)) + if (elsewhere.length > 0) { + return yield* new EnterpriseSsoInvalidError({ + message: `This person also has an email on ${Arr.join(elsewhere, ", ")}, which another organization's SSO covers, so they cannot bypass SSO from here.`, + }) + } + yield* clerk.addBypassUser(userId).pipe(Effect.mapError(fromClerk)) + return yield* get(orgId) + }) + + const removeBypassUser = Effect.fn("EnterpriseSsoService.removeBypassUser")(function* ( + orgId: OrgId, + userId: UserId, + ) { + yield* Effect.annotateCurrentSpan({ orgId, "maple.sso.bypass_user": userId }) + const row = yield* requireConnectionRow(orgId) + // The allowlist is instance-wide: only entries this org's connection serves are its to remove. + const listed = yield* clerk + .listBypassUsers(row.clerkConnectionId) + .pipe(Effect.mapError(fromClerk)) + if (!Arr.some(listed, (u) => u.userId === userId)) { + return yield* new EnterpriseSsoNotFoundError({ + message: "That person is not on this organization's bypass list.", + }) + } + const connection = yield* clerk + .getConnection(row.clerkConnectionId) + .pipe(Effect.mapError(fromClerk)) + const elsewhere = yield* coveredElsewhere( + userId, + row.clerkConnectionId, + connection.domains, + ).pipe(Effect.mapError(fromClerk)) + if (elsewhere.length > 0) { + return yield* new EnterpriseSsoConflictError({ + message: `This person also has an email on ${Arr.join(elsewhere, ", ")}, which another organization's SSO covers. Removing them here would remove that organization's break-glass access too; contact support.`, + }) + } + yield* clerk.removeBypassUser(userId).pipe(Effect.mapError(fromClerk)) + return yield* get(orgId) + }) + + const applyDirectoryGroup = Effect.fn("EnterpriseSsoService.applyDirectoryGroup")(function* ( + event: DirectoryGroupEvent, + ) { + yield* Effect.annotateCurrentSpan({ + "maple.sso.directory_id": event.directoryId, + "maple.sso.group_deleted": event.deleted, + }) + // Cross-org on purpose: the directory id is what tells us which org, if any, is ours. + const owners = yield* dbExecute((db) => + db.run( + PG.from(OrgSsoConnections) + .select() + .where(($) => [$.clerkDirectoryId.eq(event.directoryId)]) + .limit(1), + ), + ) + const owner = owners[0] + if (owner === undefined) return "not_here" as const + const orgId = owner.orgId + // A deletion is a tombstone and only newer events win, so a late redelivered + // update cannot bring a deleted group back. + const set = { + displayName: event.displayName, + updatedAt: event.updatedAt, + deletedAt: event.deleted ? event.updatedAt : null, + } + yield* dbExecute((db) => + db.run( + PG.insertInto(OrgDirectoryGroups) + .values({ orgId, directoryId: event.directoryId, groupId: event.groupId, ...set }) + .onConflictDoUpdate({ + target: ["directoryId", "groupId"], + // Ties go to the deletion: a redelivered update at the same instant stays dead. + where: ($) => + PG.and( + $.orgId.eq(orgId), + event.deleted + ? $.updatedAt.lte(event.updatedAt) + : $.updatedAt.lt(event.updatedAt), + ), + set, + }), + ), + ) + return "applied" as const + }) + + const confirmDeprovisioned = Effect.fn("EnterpriseSsoService.confirmDeprovisioned")(function* ( + userId: UserId, + ) { + const state = yield* clerk.isDeprovisioned(userId).pipe( + // A blip should not decide it: retry briefly, then fail closed. + Effect.retry({ schedule: Schedule.exponential(Duration.millis(200)), times: 2 }), + Effect.catch((error) => + Effect.logWarning( + "Could not confirm a deprovisioning with Clerk; sweeping anyway", + ).pipe(Effect.annotateLogs({ userId, error: error.message }), Effect.as(true)), + ), + ) + yield* Effect.annotateCurrentSpan({ "maple.sso.still_deprovisioned": state }) + return state + }) + + return { + confirmDeprovisioned, + get, + addDomain, + verifyDomain, + removeDomain, + createConnection, + updateConnection, + setEnforcement, + deleteConnection, + createDirectory, + rotateDirectoryToken, + setDirectoryState, + deleteDirectory, + setRoleMappings, + addBypassUser, + removeBypassUser, + applyDirectoryGroup, + } satisfies EnterpriseSsoServiceApi + }), + }, +) { + static readonly layer = Layer.effect(this, this.make).pipe( + Layer.provide( + Layer.mergeAll( + AutumnClient.layer, + BillingCustomerResolver.layer, + ClerkSsoGateway.layer, + DnsTxtResolver.layer, + ), + ), + ) + + /** Serves only the webhook's directory-group path, for route tests; settings calls fail. */ + static readonly webhookOnly = ( + apply: EnterpriseSsoServiceApi["applyDirectoryGroup"], + confirmDeprovisioned: EnterpriseSsoServiceApi["confirmDeprovisioned"] = () => Effect.succeed(true), + ) => { + const unserved = Effect.fail( + new EnterpriseSsoUnavailableError({ message: "webhookOnly serves webhooks only" }), + ) + return Layer.succeed(this, { + get: () => unserved, + addDomain: () => unserved, + verifyDomain: () => unserved, + removeDomain: () => unserved, + createConnection: () => unserved, + updateConnection: () => unserved, + setEnforcement: () => unserved, + deleteConnection: () => unserved, + createDirectory: () => unserved, + rotateDirectoryToken: () => unserved, + setDirectoryState: () => unserved, + deleteDirectory: () => unserved, + setRoleMappings: () => unserved, + addBypassUser: () => unserved, + removeBypassUser: () => unserved, + applyDirectoryGroup: apply, + confirmDeprovisioned, + }) + } +} diff --git a/packages/backend/src/services/org/enterprise-sso/__fixtures__/conformance-idp.ts b/packages/backend/src/services/org/enterprise-sso/__fixtures__/conformance-idp.ts new file mode 100644 index 0000000000..1cf474987d --- /dev/null +++ b/packages/backend/src/services/org/enterprise-sso/__fixtures__/conformance-idp.ts @@ -0,0 +1,19 @@ +/** A throwaway self-signed IdP signing certificate (public half only) for the live SCIM run. */ +export const CONFORMANCE_IDP_CERTIFICATE = `-----BEGIN CERTIFICATE----- +MIICxjCCAa4CCQCBkQStOdASFDANBgkqhkiG9w0BAQsFADAlMSMwIQYDVQQDDBpt +YXBsZS1zY2ltLWNvbmZvcm1hbmNlLWlkcDAeFw0yNjExMTYxNjE1MDJaFw0zNjEx +MTMxNjE1MDJaMCUxIzAhBgNVBAMMGm1hcGxlLXNjaW0tY29uZm9ybWFuY2UtaWRw +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAu3y9JV65IolPFV8pXU2/ +lWYVFa36RTL8No8ob/LDdGXRTEJGt0urZjHQwy8glibdQt6QCQm4GY+69y0+sPYG +RH81kRW90rTDf8Th3bPHXiMrOeAx+NIYmO4TK1eNsOA7EOnTcYlORaxJmPQcdsSn +c5puUbd7Oy1ICp+anSo1Y6ThikQZz80UCnr23yyRycnHMGcevHyhOlmKCzlPLyWO +gLHyXyNgYtW5Kb331OcRFc+3wO8NFWgQ2kMIsIdCuURfxXya/4LC25CbsO5cminy +4fvQOtgRXA0ts2oXJDdSaJZx8G6iKqvT7ZcPkZPvfA/QK5fb9WIP26ZijEe7xc2/ +AwIDAQABMA0GCSqGSIb3DQEBCwUAA4IBAQCn+PB4ZNfA+/ebElWuxicy1D9SshUd +o01BPR8wv1CEpboevv6fJ6vo85khZvWbwoJ8FGK45iCI17FkSkTtZ6nLeKJk/H4b +Ma+ILGNbk4G67RHv48K4aYDwqw0dMErjUdi2QO+eclG27KqZbcuR2+szlCys7ATg +IJNwq2Fs/eHOocMHSIPW0e1TciQG3/zDub980ukacmgspsHbMGoxJVfQOSAyepHD +iZeYIS+GNDnA0GKcWbMO9mPQUCaCTH9oVVVGalAS94HVTz8qDn9VWRovg4/LCIzN +0l18NKGCauooXz6ZN9DQjzEFvwoCDZ1TMZbKf2rjRFUUfTdpzaZYCBn1 +-----END CERTIFICATE----- +` diff --git a/packages/backend/src/services/org/enterprise-sso/scim-conformance.live.test.ts b/packages/backend/src/services/org/enterprise-sso/scim-conformance.live.test.ts new file mode 100644 index 0000000000..1c74bc1c6d --- /dev/null +++ b/packages/backend/src/services/org/enterprise-sso/scim-conformance.live.test.ts @@ -0,0 +1,263 @@ +import { assert, describe, it } from "@effect/vitest" +import { createClerkClient } from "@clerk/backend" +import { OrgId } from "@maple/domain/http" +import { + Array as Arr, + ConfigProvider, + Duration, + Effect, + Layer, + Option, + Schedule, + Schema, + String as Str, +} from "effect" +import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http" +import * as SecureRandom from "effect/crypto/SecureRandom" +import * as Hex from "effect/encoding/Hex" +import { Env } from "@maple/backend/platform/Env" +import { CONFORMANCE_IDP_CERTIFICATE } from "./__fixtures__/conformance-idp" +import { ClerkSsoGateway } from "./ClerkSsoGateway" + +// SCIM 2.0 conformance against a real Clerk instance, through Maple's own gateway. Opt-in only: +// infisical run --env dev -- env SCIM_CONFORMANCE=1 bunx vitest run scim-conformance.live + +const SECRET = process.env.CLERK_SECRET_KEY ?? "" +const ENABLED = process.env.SCIM_CONFORMANCE === "1" && Str.startsWith("sk_test_")(SECRET) + +const config = ConfigProvider.layer( + ConfigProvider.fromUnknown({ + PORT: "3472", + TINYBIRD_HOST: "https://api.tinybird.co", + TINYBIRD_TOKEN: "test-token", + TINYBIRD_SIGNING_KEY: "unused-signing-key", + TINYBIRD_WORKSPACE_ID: "unused-workspace", + MAPLE_AUTH_MODE: "clerk", + CLERK_SECRET_KEY: SECRET, + CLERK_PUBLISHABLE_KEY: process.env.CLERK_PUBLISHABLE_KEY ?? "pk_test_unused", + MAPLE_DEFAULT_ORG_ID: "default", + MAPLE_INGEST_KEY_ENCRYPTION_KEY: Buffer.alloc(32, 9).toString("base64"), + MAPLE_INGEST_KEY_LOOKUP_HMAC_KEY: "maple-test-lookup-secret", + MAPLE_INGEST_PUBLIC_URL: "https://ingest.test", + }), +) + +const gatewayLayer = ClerkSsoGateway.layer.pipe(Layer.provide(Env.layer), Layer.provide(config)) + +const ScimResource = Schema.fromJsonString(Schema.Struct({ id: Schema.String })) +const ClerkUserFlags = Schema.fromJsonString( + Schema.Struct({ deprovisioned: Schema.optionalKey(Schema.Boolean) }), +) + +interface ScimResponse { + readonly status: number + readonly body: string +} + +/** Clerk applies SCIM changes in the background; poll until `check` holds or give up. */ +const eventually = (label: string, read: Effect.Effect, check: (a: A) => boolean) => + read.pipe( + Effect.filterOrFail(check, () => new Error(`timed out waiting for ${label}`)), + Effect.retry({ schedule: Schedule.spaced(Duration.seconds(2)), times: 30 }), + Effect.orDie, + ) + +describe.skipIf(!ENABLED)("SCIM conformance (live Clerk dev instance)", () => { + it.live( + "creates, patches and deactivates users, and maps group membership to a role", + () => + Effect.gen(function* () { + const clerk = createClerkClient({ secretKey: SECRET }) + const gateway = yield* ClerkSsoGateway + const http = yield* HttpClient.HttpClient + const suffix = Hex.encode(SecureRandom.randomBytesUnsafe(4)) + const domain = `scim-${suffix}.maple.dev` + const report: Array = [] + const step = (line: string) => Effect.sync(() => void report.push(line)) + + const org = yield* Effect.promise(() => + clerk.organizations.createOrganization({ name: `SCIM conformance ${suffix}` }), + ) + const orgId = Schema.decodeSync(OrgId)(org.id) + const cleanup: Array> = [ + Effect.promise(() => clerk.organizations.deleteOrganization(org.id)).pipe(Effect.asVoid), + ] + const undoLater = (undo: Effect.Effect) => + Effect.sync(() => void cleanup.unshift(undo.pipe(Effect.ignore))) + + yield* Effect.gen(function* () { + const domainId = yield* gateway.ensureOrgDomain(orgId, domain) + yield* gateway.verifyOrgDomainOwnership(orgId, domainId) + yield* step(`domain ${domain}: ownership verified (manual override)`) + + const connection = yield* gateway.createConnection(orgId, "saml_custom", { + name: "Conformance IdP", + domains: [domain], + saml: { + ssoUrl: "https://idp.example.com/sso", + entityId: "https://idp.example.com", + certificate: CONFORMANCE_IDP_CERTIFICATE, + }, + }) + yield* undoLater(gateway.deleteConnection(connection.id)) + assert.isFalse(connection.active) + assert.isNotNull(connection.saml?.acsUrl ?? null) + yield* step( + `connection ${connection.id}: created inactive, ACS ${connection.saml?.acsUrl}`, + ) + + const directory = yield* gateway.createDirectory(connection.id, "custom") + yield* undoLater(gateway.deleteDirectory(directory.id)) + const firstKey = directory.api_key ?? "" + assert.isAbove(firstKey.length, 10) + const rotated = yield* gateway.rotateDirectoryKey(directory.id) + const token = rotated.api_key ?? "" + assert.notStrictEqual(token, firstKey) + yield* step(`directory ${directory.id}: endpoint ${directory.endpoint_url}, key rotated`) + + const base = Str.replace(/\/$/, "")(directory.endpoint_url) + const scim = (method: "GET" | "POST" | "PATCH", path: string, payload?: unknown) => + Effect.gen(function* () { + const request = HttpClientRequest.make(method)(`${base}${path}`).pipe( + HttpClientRequest.bearerToken(token), + HttpClientRequest.setHeader("content-type", "application/scim+json"), + HttpClientRequest.acceptJson, + ) + const response = yield* http.execute( + payload === undefined + ? request + : HttpClientRequest.bodyJsonUnsafe(request, payload), + ) + const body = yield* response.text + return { status: response.status, body } satisfies ScimResponse + }).pipe(Effect.orDie) + const resourceId = (response: ScimResponse) => + Schema.decodeSync(ScimResource)(response.body).id + + const email = `ada@${domain}` + const created = yield* scim("POST", "/Users", { + schemas: ["urn:ietf:params:scim:schemas:core:2.0:User"], + userName: email, + name: { givenName: "Ada", familyName: "Lovelace" }, + emails: [{ value: email, primary: true, type: "work" }], + active: true, + }) + assert.strictEqual(created.status, 201, created.body) + const scimUserId = resourceId(created) + yield* step(`POST /Users -> ${created.status}`) + + const fetched = yield* scim("GET", `/Users/${scimUserId}`) + assert.strictEqual(fetched.status, 200) + yield* step(`GET /Users/{id} -> ${fetched.status}`) + + const clerkUsers = yield* eventually( + "the Clerk user", + Effect.promise(() => clerk.users.getUserList({ emailAddress: [email] })), + (page) => page.data.length === 1, + ) + const userId = Option.getOrElse( + Option.map(Arr.head(clerkUsers.data), (u) => u.id), + () => "", + ) + yield* undoLater(Effect.promise(() => clerk.users.deleteUser(userId))) + const memberships = Effect.promise(() => + clerk.organizations.getOrganizationMembershipList({ organizationId: org.id }), + ).pipe( + Effect.map((page) => + Option.map( + Arr.findFirst(page.data, (m) => m.publicUserData?.userId === userId), + (m) => m.role, + ), + ), + ) + const joined = yield* eventually("the membership", memberships, Option.isSome) + yield* step( + `Clerk user ${userId} provisioned, member as ${Option.getOrElse(joined, () => "?")}`, + ) + + const patched = yield* scim("PATCH", `/Users/${scimUserId}`, { + schemas: ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], + Operations: [{ op: "replace", path: "name.givenName", value: "Augusta" }], + }) + assert.strictEqual(patched.status, 200, patched.body) + yield* eventually( + "the renamed user", + Effect.promise(() => clerk.users.getUser(userId)), + (u) => u.firstName === "Augusta", + ) + yield* step(`PATCH /Users/{id} name -> ${patched.status}, Clerk firstName updated`) + + const group = yield* scim("POST", "/Groups", { + schemas: ["urn:ietf:params:scim:schemas:core:2.0:Group"], + displayName: "Maple Analysts", + members: [{ value: scimUserId }], + }) + assert.strictEqual(group.status, 201, group.body) + const groupId = resourceId(group) + yield* step(`POST /Groups with member -> ${group.status}`) + + const roles = yield* gateway.listRoles + const analyst = Arr.findFirst(roles, (r) => r.key === "org:analyst") + assert.isTrue(Option.isSome(analyst), "org:analyst must exist in this Clerk instance") + const analystId = Option.getOrElse( + Option.map(analyst, (r) => r.id), + () => "", + ) + // The same calls EnterpriseSsoService.setRoleMappings makes. + yield* gateway.replaceRoleMappings(directory.id, [{ groupId, roleId: analystId }]) + yield* gateway.updateDirectory(directory.id, { group_role_mapping_enabled: true }) + const mappings = yield* gateway.listRoleMappings(directory.id) + assert.deepStrictEqual( + Arr.map(mappings, (m) => [m.groupId, m.roleKey]), + [[groupId, "org:analyst"]], + ) + // A saved mapping reaches existing members on the IdP's next group push, as Okta's + // "Push now" or Entra's sync cycle does; Clerk does not apply it on save. + const repush = yield* scim("PATCH", `/Groups/${groupId}`, { + schemas: ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], + Operations: [{ op: "add", path: "members", value: [{ value: scimUserId }] }], + }) + assert.strictEqual(repush.status, 200, repush.body) + yield* eventually("the analyst role", memberships, (role) => + Option.contains(role, "org:analyst"), + ) + yield* step("group mapped to org:analyst, member role is org:analyst after the next push") + + const deactivated = yield* scim("PATCH", `/Users/${scimUserId}`, { + schemas: ["urn:ietf:params:scim:api:messages:2.0:PatchOp"], + Operations: [{ op: "replace", value: { active: false } }], + }) + assert.strictEqual(deactivated.status, 200, deactivated.body) + yield* eventually("the removed membership", memberships, Option.isNone) + // Maple's webhook keys its user sweep on this flag (user.updated, deprovisioned: true). + const flags = yield* eventually( + "the deprovisioned flag", + http + .execute( + HttpClientRequest.get(`https://api.clerk.com/v1/users/${userId}`).pipe( + HttpClientRequest.bearerToken(SECRET), + HttpClientRequest.setHeader("Clerk-API-Version", "2026-05-12"), + ), + ) + .pipe( + Effect.flatMap((response) => response.text), + Effect.map(Schema.decodeSync(ClerkUserFlags)), + ), + (u) => u.deprovisioned === true, + ) + assert.isTrue(flags.deprovisioned) + yield* step( + `PATCH active=false -> ${deactivated.status}, membership removed, user deprovisioned=true`, + ) + + yield* Effect.logInfo( + `SCIM conformance report\n${Arr.join( + Arr.map(report, (l) => ` - ${l}`), + "\n", + )}`, + ) + }).pipe(Effect.ensuring(Effect.suspend(() => Effect.all(cleanup, { discard: true })))) + }).pipe(Effect.provide([gatewayLayer, FetchHttpClient.layer])), + 180_000, + ) +}) diff --git a/packages/backend/src/services/product-events/clerk-events.ts b/packages/backend/src/services/product-events/clerk-events.ts index 3c062b5043..87608de742 100644 --- a/packages/backend/src/services/product-events/clerk-events.ts +++ b/packages/backend/src/services/product-events/clerk-events.ts @@ -70,6 +70,30 @@ export const ClerkUserDeletedData = Schema.Struct({ id: Schema.optionalKey(Schema.String), }) +/** `user.updated`: only the fields Maple acts on. `deprovisioned` is set by SCIM deactivation. */ +export const ClerkUserUpdatedData = Schema.Struct({ + id: Schema.String, + deprovisioned: Schema.optionalKey(Schema.NullOr(Schema.Boolean)), +}) + +/** `directoryGroup.*`: a group the IdP pushed over SCIM. */ +export const ClerkDirectoryGroupData = Schema.Struct({ + id: Schema.String, + directory_id: Schema.String, + display_name: Schema.String, + updated_at: Schema.Number, +}) + +export const CLERK_DIRECTORY_GROUP_EVENTS = [ + "directoryGroup.created", + "directoryGroup.updated", + "directoryGroup.synced", + "directoryGroup.deleted", +] as const +export type ClerkDirectoryGroupEventType = (typeof CLERK_DIRECTORY_GROUP_EVENTS)[number] +export const isClerkDirectoryGroupEvent = (type: string): type is ClerkDirectoryGroupEventType => + (CLERK_DIRECTORY_GROUP_EVENTS as ReadonlyArray).includes(type) + export const ClerkWebhookEnvelope = Schema.Struct({ type: Schema.String, data: Schema.Unknown, @@ -82,6 +106,8 @@ export const decodeClerkEnvelope = Schema.decodeUnknownEffect(Schema.fromJsonStr export const decodeClerkUserCreated = Schema.decodeUnknownEffect(ClerkUserCreatedData) export const decodeClerkOrganizationMembership = Schema.decodeUnknownEffect(ClerkOrganizationMembershipData) export const decodeClerkUserDeleted = Schema.decodeUnknownEffect(ClerkUserDeletedData) +export const decodeClerkUserUpdated = Schema.decodeUnknownEffect(ClerkUserUpdatedData) +export const decodeClerkDirectoryGroup = Schema.decodeUnknownEffect(ClerkDirectoryGroupData) type ClerkUserCreatedData = Schema.Schema.Type const emailDomain = (data: ClerkUserCreatedData): string | undefined => { diff --git a/packages/db/drizzle/20261116163516_enterprise_sso/migration.sql b/packages/db/drizzle/20261116163516_enterprise_sso/migration.sql new file mode 100644 index 0000000000..c4984fcd6e --- /dev/null +++ b/packages/db/drizzle/20261116163516_enterprise_sso/migration.sql @@ -0,0 +1,43 @@ +-- metadata +CREATE TABLE IF NOT EXISTS "org_directory_groups" ( + "org_id" text NOT NULL, + "directory_id" text NOT NULL, + "group_id" text NOT NULL, + "display_name" text NOT NULL, + "updated_at" timestamp with time zone NOT NULL, + "deleted_at" timestamp with time zone, + CONSTRAINT "org_directory_groups_pkey" PRIMARY KEY ("directory_id", "group_id") +); +--> statement-breakpoint +-- metadata +CREATE TABLE IF NOT EXISTS "org_sso_connections" ( + "org_id" text NOT NULL, + "clerk_connection_id" text NOT NULL, + "clerk_directory_id" text, + "created_at" timestamp with time zone NOT NULL, + "created_by" text NOT NULL, + "updated_at" timestamp with time zone NOT NULL, + CONSTRAINT "org_sso_connections_pkey" PRIMARY KEY ("org_id") +); +--> statement-breakpoint +-- metadata +CREATE TABLE IF NOT EXISTS "org_sso_domains" ( + "org_id" text NOT NULL, + "domain" text NOT NULL, + "challenge" text NOT NULL, + "status" text NOT NULL, + "clerk_domain_id" text, + "verified_at" timestamp with time zone, + "created_at" timestamp with time zone NOT NULL, + "created_by" text NOT NULL, + CONSTRAINT "org_sso_domains_pkey" PRIMARY KEY ("org_id", "domain") +); +--> statement-breakpoint +-- metadata +CREATE INDEX IF NOT EXISTS "org_directory_groups_org_idx" ON "org_directory_groups" USING btree ("org_id"); +--> statement-breakpoint +-- metadata +CREATE UNIQUE INDEX IF NOT EXISTS "org_sso_connections_connection_unq" ON "org_sso_connections" USING btree ("clerk_connection_id"); +--> statement-breakpoint +-- metadata +CREATE UNIQUE INDEX IF NOT EXISTS "org_sso_connections_directory_unq" ON "org_sso_connections" USING btree ("clerk_directory_id"); diff --git a/packages/db/drizzle/20261116163516_enterprise_sso/snapshot.json b/packages/db/drizzle/20261116163516_enterprise_sso/snapshot.json new file mode 100644 index 0000000000..2e1ce447db --- /dev/null +++ b/packages/db/drizzle/20261116163516_enterprise_sso/snapshot.json @@ -0,0 +1,23476 @@ +{ + "version": "1", + "dialect": "postgres", + "id": "24fe01e1e14727a6af35609d1b4729fc95ca400925198675ba15a9900e5bbbc4", + "prevIds": [ + "5fa05f5b16fe30b3669d13615281ef6457c8ed2742d1203703e4c696a396bb47" + ], + "entities": [ + { + "kind": "table", + "name": "actors", + "primaryKey": { + "name": "actors_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "agent_feedback", + "primaryKey": { + "name": "agent_feedback_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "ai_triage_settings", + "primaryKey": { + "name": "ai_triage_settings_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "alert_delivery_events", + "primaryKey": { + "name": "alert_delivery_events_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "alert_destinations", + "primaryKey": { + "name": "alert_destinations_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "alert_escalation_runs", + "primaryKey": { + "name": "alert_escalation_runs_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "alert_incident_events", + "primaryKey": { + "name": "alert_incident_events_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "alert_incidents", + "primaryKey": { + "name": "alert_incidents_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "alert_linear_issues", + "primaryKey": { + "name": "alert_linear_issues_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "alert_maintenance_windows", + "primaryKey": { + "name": "alert_maintenance_windows_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "alert_member_notifications", + "primaryKey": { + "name": "alert_member_notifications_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "alert_rule_claims", + "primaryKey": { + "name": "alert_rule_claims_pkey", + "columns": [ + "rule_id" + ] + } + }, + { + "kind": "table", + "name": "alert_rule_states", + "primaryKey": { + "name": "alert_rule_states_org_id_rule_id_group_key_pk", + "columns": [ + "org_id", + "rule_id", + "group_key" + ] + } + }, + { + "kind": "table", + "name": "alert_rules", + "primaryKey": { + "name": "alert_rules_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "alert_silences", + "primaryKey": { + "name": "alert_silences_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "anomaly_detector_settings", + "primaryKey": { + "name": "anomaly_detector_settings_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "anomaly_detector_states", + "primaryKey": { + "name": "anomaly_detector_states_org_id_detector_key_pk", + "columns": [ + "org_id", + "detector_key" + ] + } + }, + { + "kind": "table", + "name": "anomaly_incidents", + "primaryKey": { + "name": "anomaly_incidents_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "api_keys", + "primaryKey": { + "name": "api_keys_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "aws_connections", + "primaryKey": { + "name": "aws_connections_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "cancellation_reviews", + "primaryKey": { + "name": "cancellation_reviews_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "chat_identities", + "primaryKey": { + "name": "chat_identities_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "chat_workspaces", + "primaryKey": { + "name": "chat_workspaces_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "cli_device_authorizations", + "primaryKey": { + "name": "cli_device_authorizations_pkey", + "columns": [ + "device_code_hash" + ] + } + }, + { + "kind": "table", + "name": "cloudflare_analytics_state", + "primaryKey": { + "name": "cloudflare_analytics_state_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "cloudflare_feature_settings", + "primaryKey": { + "name": "cloudflare_feature_settings_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "cloudflare_hyperdrive_configs", + "primaryKey": { + "name": "cloudflare_hyperdrive_configs_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "cloudflare_logpush_connectors", + "primaryKey": { + "name": "cloudflare_logpush_connectors_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "cloudflare_zone_settings", + "primaryKey": { + "name": "cloudflare_zone_settings_pkey", + "columns": [ + "org_id", + "account_id" + ] + } + }, + { + "kind": "table", + "name": "cost_connections", + "primaryKey": { + "name": "cost_connections_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "cost_sources", + "primaryKey": { + "name": "cost_sources_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "dashboard_shares", + "primaryKey": { + "name": "dashboard_shares_org_id_id_pk", + "columns": [ + "org_id", + "id" + ] + } + }, + { + "kind": "table", + "name": "dashboard_versions", + "primaryKey": { + "name": "dashboard_versions_org_id_id_pk", + "columns": [ + "org_id", + "id" + ] + } + }, + { + "kind": "table", + "name": "dashboards", + "primaryKey": { + "name": "dashboards_org_id_id_pk", + "columns": [ + "org_id", + "id" + ] + } + }, + { + "kind": "table", + "name": "dependency_findings", + "primaryKey": { + "name": "dependency_findings_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "dependency_scan_matches", + "primaryKey": { + "name": "dependency_scan_matches_pkey", + "columns": [ + "scan_id", + "lockfile_path", + "ecosystem", + "package_name", + "version", + "advisory_id" + ] + } + }, + { + "kind": "table", + "name": "dependency_scans", + "primaryKey": { + "name": "dependency_scans_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "device_credentials", + "primaryKey": { + "name": "device_credentials_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "device_proof_replays", + "primaryKey": { + "name": "device_proof_replays_pkey", + "columns": [ + "key" + ] + } + }, + { + "kind": "table", + "name": "digest_subscriptions", + "primaryKey": { + "name": "digest_subscriptions_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "error_fingerprint_candidates", + "primaryKey": { + "name": "error_fingerprint_candidates_org_id_fingerprint_hash_pk", + "columns": [ + "org_id", + "fingerprint_hash" + ] + } + }, + { + "kind": "table", + "name": "error_incidents", + "primaryKey": { + "name": "error_incidents_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "error_issue_events", + "primaryKey": { + "name": "error_issue_events_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "error_issue_fingerprints", + "primaryKey": { + "name": "error_issue_fingerprints_org_id_fingerprint_hash_pk", + "columns": [ + "org_id", + "fingerprint_hash" + ] + } + }, + { + "kind": "table", + "name": "error_issue_pull_requests", + "primaryKey": { + "name": "error_issue_pull_requests_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "error_issue_states", + "primaryKey": { + "name": "error_issue_states_org_id_issue_id_pk", + "columns": [ + "org_id", + "issue_id" + ] + } + }, + { + "kind": "table", + "name": "error_issue_verifications", + "primaryKey": { + "name": "error_issue_verifications_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "error_issues", + "primaryKey": { + "name": "error_issues_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "error_notification_deliveries", + "primaryKey": { + "name": "error_notification_deliveries_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "error_notification_policies", + "primaryKey": { + "name": "error_notification_policies_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "error_tick_states", + "primaryKey": { + "name": "error_tick_states_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "escalation_chains", + "primaryKey": { + "name": "escalation_chains_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "external_data_source_catalog_entries", + "primaryKey": { + "name": "external_data_source_catalog_entries_pk", + "columns": [ + "source_id", + "name" + ] + } + }, + { + "kind": "table", + "name": "external_data_sources", + "primaryKey": { + "name": "external_data_sources_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "gcp_connectors", + "primaryKey": { + "name": "gcp_connectors_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "gcp_resources", + "primaryKey": { + "name": "gcp_resources_pkey", + "columns": [ + "connector_id", + "name" + ] + } + }, + { + "kind": "table", + "name": "investigations", + "primaryKey": { + "name": "investigations_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "issue_escalation_policies", + "primaryKey": { + "name": "issue_escalation_policies_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "issue_escalations", + "primaryKey": { + "name": "issue_escalations_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "linear_feature_settings", + "primaryKey": { + "name": "linear_feature_settings_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "live_activities", + "primaryKey": { + "name": "live_activities_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "mcp_oauth_authorizations", + "primaryKey": { + "name": "mcp_oauth_authorizations_pkey", + "columns": [ + "request_id_hash" + ] + } + }, + { + "kind": "table", + "name": "mcp_oauth_clients", + "primaryKey": { + "name": "mcp_oauth_clients_pkey", + "columns": [ + "client_id" + ] + } + }, + { + "kind": "table", + "name": "mcp_oauth_refresh_tokens", + "primaryKey": { + "name": "mcp_oauth_refresh_tokens_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "mobile_devices", + "primaryKey": { + "name": "mobile_devices_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "oauth_auth_states", + "primaryKey": { + "name": "oauth_auth_states_pkey", + "columns": [ + "state" + ] + } + }, + { + "kind": "table", + "name": "oauth_connections", + "primaryKey": { + "name": "oauth_connections_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "oncall_overrides", + "primaryKey": { + "name": "oncall_overrides_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "oncall_schedules", + "primaryKey": { + "name": "oncall_schedules_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "openrouter_cost_connections", + "primaryKey": { + "name": "openrouter_cost_connections_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "org_billing_links", + "primaryKey": { + "name": "org_billing_links_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "org_clickhouse_schema_apply_runs", + "primaryKey": { + "name": "org_clickhouse_schema_apply_runs_org_id_pk", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "org_clickhouse_settings", + "primaryKey": { + "name": "org_clickhouse_settings_org_id_pk", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "org_directory_groups", + "primaryKey": { + "name": "org_directory_groups_pkey", + "columns": [ + "directory_id", + "group_id" + ] + } + }, + { + "kind": "table", + "name": "org_ingest_attribute_mappings", + "primaryKey": { + "name": "org_ingest_attribute_mappings_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "org_ingest_keys", + "primaryKey": { + "name": "org_ingest_keys_org_id_pk", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "org_ingest_rule_settings", + "primaryKey": { + "name": "org_ingest_rule_settings_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "org_ingest_rule_stats", + "primaryKey": { + "name": "org_ingest_rule_stats_pkey", + "columns": [ + "org_id", + "rule_id", + "bucket", + "signal" + ] + } + }, + { + "kind": "table", + "name": "org_ingest_rules", + "primaryKey": { + "name": "org_ingest_rules_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "org_ingest_sampling_policies", + "primaryKey": { + "name": "org_ingest_sampling_policies_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "org_onboarding_state", + "primaryKey": { + "name": "org_onboarding_state_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "org_openrouter_keys", + "primaryKey": { + "name": "org_openrouter_keys_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "org_recommendation_issues", + "primaryKey": { + "name": "org_recommendation_issues_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "org_sso_connections", + "primaryKey": { + "name": "org_sso_connections_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "org_sso_domains", + "primaryKey": { + "name": "org_sso_domains_pkey", + "columns": [ + "org_id", + "domain" + ] + } + }, + { + "kind": "table", + "name": "org_support_channels", + "primaryKey": { + "name": "org_support_channels_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "planetscale_connections", + "primaryKey": { + "name": "planetscale_connections_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "planetscale_databases", + "primaryKey": { + "name": "planetscale_databases_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "planetscale_events", + "primaryKey": { + "name": "planetscale_events_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "planetscale_issue_receipts", + "primaryKey": { + "name": "planetscale_issue_receipts_org_id_event_id_pk", + "columns": [ + "org_id", + "event_id" + ] + } + }, + { + "kind": "table", + "name": "planetscale_poll_state", + "primaryKey": { + "name": "planetscale_poll_state_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "pr_review_edits", + "primaryKey": { + "name": "pr_review_edits_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "pr_review_finding_embeddings", + "primaryKey": { + "name": "pr_review_finding_embeddings_pkey", + "columns": [ + "finding_id" + ] + } + }, + { + "kind": "table", + "name": "pr_review_findings", + "primaryKey": { + "name": "pr_review_findings_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "pr_review_merge_steps", + "primaryKey": { + "name": "pr_review_merge_steps_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "pr_review_replies", + "primaryKey": { + "name": "pr_review_replies_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "pr_review_settings", + "primaryKey": { + "name": "pr_review_settings_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "pr_reviews", + "primaryKey": { + "name": "pr_reviews_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "railway_connections", + "primaryKey": { + "name": "railway_connections_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "railway_environments", + "primaryKey": { + "name": "railway_environments_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "saved_views", + "primaryKey": { + "name": "saved_views_org_id_id_pk", + "columns": [ + "org_id", + "id" + ] + } + }, + { + "kind": "table", + "name": "scrape_target_checks", + "primaryKey": { + "name": "scrape_target_checks_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "scrape_targets", + "primaryKey": { + "name": "scrape_targets_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "search_console_sites", + "primaryKey": { + "name": "search_console_sites_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "security_audit_events", + "primaryKey": { + "name": "security_audit_events_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "security_audit_findings", + "primaryKey": { + "name": "security_audit_findings_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "security_audit_org_reservations", + "primaryKey": { + "name": "security_audit_org_reservations_pkey", + "columns": [ + "run_id", + "agent_id" + ] + } + }, + { + "kind": "table", + "name": "security_audit_org_settings", + "primaryKey": { + "name": "security_audit_org_settings_pkey", + "columns": [ + "org_id" + ] + } + }, + { + "kind": "table", + "name": "security_audit_run_findings", + "primaryKey": { + "name": "security_audit_run_findings_pkey", + "columns": [ + "run_id", + "fingerprint" + ] + } + }, + { + "kind": "table", + "name": "security_audit_runs", + "primaryKey": { + "name": "security_audit_runs_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "security_audit_targets", + "primaryKey": { + "name": "security_audit_targets_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "security_audit_units", + "primaryKey": { + "name": "security_audit_units_pkey", + "columns": [ + "run_id", + "coverage_id" + ] + } + }, + { + "kind": "table", + "name": "service_map_world_entities", + "primaryKey": { + "name": "service_map_world_entities_pkey", + "columns": [ + "org_id", + "entity_id" + ] + } + }, + { + "kind": "table", + "name": "slos", + "primaryKey": { + "name": "slos_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "sources", + "primaryKey": { + "name": "sources_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "status_page_cleanups", + "primaryKey": { + "name": "status_page_cleanups_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "status_page_components", + "primaryKey": { + "name": "status_page_components_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "status_page_custom_domains", + "primaryKey": { + "name": "status_page_custom_domains_pkey", + "columns": [ + "page_id" + ] + } + }, + { + "kind": "table", + "name": "status_page_incident_components", + "primaryKey": { + "name": "status_page_incident_components_pk", + "columns": [ + "incident_id", + "component_id" + ] + } + }, + { + "kind": "table", + "name": "status_page_incident_updates", + "primaryKey": { + "name": "status_page_incident_updates_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "status_page_incidents", + "primaryKey": { + "name": "status_page_incidents_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "status_pages", + "primaryKey": { + "name": "status_pages_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "supabase_connections", + "primaryKey": { + "name": "supabase_connections_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "supabase_project_insights", + "primaryKey": { + "name": "supabase_project_insights_pkey", + "columns": [ + "project_id" + ] + } + }, + { + "kind": "table", + "name": "supabase_projects", + "primaryKey": { + "name": "supabase_projects_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "uptime_monitor_daily", + "primaryKey": { + "name": "uptime_monitor_daily_pk", + "columns": [ + "monitor_id", + "day" + ] + } + }, + { + "kind": "table", + "name": "uptime_monitor_states", + "primaryKey": { + "name": "uptime_monitor_states_pkey", + "columns": [ + "monitor_id" + ] + } + }, + { + "kind": "table", + "name": "uptime_monitors", + "primaryKey": { + "name": "uptime_monitors_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "vcs_commits", + "primaryKey": { + "name": "vcs_commits_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "vcs_installations", + "primaryKey": { + "name": "vcs_installations_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "vcs_repositories", + "primaryKey": { + "name": "vcs_repositories_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "vcs_repository_branches", + "primaryKey": { + "name": "vcs_repository_branches_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "vercel_connections", + "primaryKey": { + "name": "vercel_connections_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "vercel_deployments", + "primaryKey": { + "name": "vercel_deployments_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "table", + "name": "vercel_projects", + "primaryKey": { + "name": "vercel_projects_pkey", + "columns": [ + "id" + ] + } + }, + { + "kind": "column", + "table": "actors", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "actors", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "actors", + "name": "type", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "actors", + "name": "user_id", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "actors", + "name": "agent_name", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "actors", + "name": "model", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "actors", + "name": "capabilities_json", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "actors", + "name": "created_by", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "actors", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "actors", + "name": "last_active_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "user_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "kind", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "impact", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "summary", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "reason", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "details", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "related_to", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "agent_type", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "agent_name", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "agent_model", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "agent_version", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "source", + "position": 13, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "agent_feedback", + "name": "created_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "ai_triage_settings", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "ai_triage_settings", + "name": "enabled", + "position": 1, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "ai_triage_settings", + "name": "max_runs_per_day", + "position": 2, + "type": "integer", + "notNull": true, + "default": "20", + "identity": null + }, + { + "kind": "column", + "table": "ai_triage_settings", + "name": "max_passes_per_day", + "position": 3, + "type": "integer", + "notNull": true, + "default": "90", + "identity": null + }, + { + "kind": "column", + "table": "ai_triage_settings", + "name": "updated_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "ai_triage_settings", + "name": "updated_by", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "incident_id", + "position": 2, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "rule_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "destination_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "delivery_key", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "event_type", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "attempt_number", + "position": 7, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "status", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "scheduled_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "claimed_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "claim_expires_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "claimed_by", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "attempted_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "provider_message", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "provider_reference", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "response_code", + "position": 16, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "error_message", + "position": 17, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "silence_id", + "position": 18, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "payload_json", + "position": 19, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "created_at", + "position": 20, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_delivery_events", + "name": "updated_at", + "position": 21, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "type", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "enabled", + "position": 4, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "config_json", + "position": 5, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "secret_ciphertext", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "secret_iv", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "secret_tag", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "last_tested_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "last_test_error", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "consecutive_failures", + "position": 11, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "last_failure_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "disabled_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "disabled_reason", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "created_by", + "position": 17, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_destinations", + "name": "updated_by", + "position": 18, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "incident_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "chain_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "chain_name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "severity", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "steps_json", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "repeat_count", + "position": 7, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "step_index", + "position": 8, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "pass_index", + "position": 9, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "next_step_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "status", + "position": 11, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "payload_json", + "position": 12, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "steps_sent", + "position": 13, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "last_step_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "ended_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "created_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_escalation_runs", + "name": "updated_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incident_events", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incident_events", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incident_events", + "name": "incident_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incident_events", + "name": "type", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incident_events", + "name": "actor_user_id", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incident_events", + "name": "actor_name", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incident_events", + "name": "source", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incident_events", + "name": "created_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "rule_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "incident_key", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "rule_name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "group_key", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "signal_type", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "severity", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "peak_severity", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "status", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "comparator", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "threshold", + "position": 11, + "type": "double precision", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "threshold_upper", + "position": 12, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "first_triggered_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "last_triggered_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "resolved_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "last_observed_value", + "position": 16, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "last_sample_count", + "position": 17, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "last_evaluated_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "dedupe_key", + "position": 19, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "last_delivered_event_type", + "position": 20, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "last_notified_at", + "position": 21, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "hold_reason", + "position": 22, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "held_since", + "position": 23, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "acknowledged_at", + "position": 24, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "acknowledged_by_user_id", + "position": 25, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "acknowledged_by_name", + "position": 26, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "acknowledged_via", + "position": 27, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "error_issue_id", + "position": 28, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "anomaly_incident_id", + "position": 29, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "group_label", + "position": 30, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "labels_json", + "position": 31, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "silence_id", + "position": 32, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "silenced_at", + "position": 33, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "created_at", + "position": 34, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_incidents", + "name": "updated_at", + "position": 35, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "destination_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "thread_key", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "linear_team_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "linear_issue_id", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "linear_identifier", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "linear_url", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "incident_id", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "created_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_linear_issues", + "name": "updated_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "reason", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "matchers_json", + "position": 4, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "schedule_json", + "position": 5, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "exclude_from_baselines", + "position": 6, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "enabled", + "position": 7, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "once_ends_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "revision", + "position": 9, + "type": "integer", + "notNull": true, + "default": "1", + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "created_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "updated_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "created_by", + "position": 12, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_maintenance_windows", + "name": "updated_by", + "position": 13, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "incident_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "run_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "user_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "channel", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "status", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "attempt_number", + "position": 7, + "type": "integer", + "notNull": true, + "default": "1", + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "scheduled_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "claimed_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "claim_expires_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "payload_json", + "position": 11, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "dedupe_key", + "position": 12, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "error_message", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "attempted_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_member_notifications", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_claims", + "name": "rule_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_claims", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_claims", + "name": "last_scheduled_at", + "position": 2, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_claims", + "name": "consecutive_limit_failures", + "position": 3, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "rule_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "group_key", + "position": 2, + "type": "text", + "notNull": true, + "default": "'__total__'", + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "consecutive_breaches", + "position": 3, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "consecutive_healthy", + "position": 4, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "history_json", + "position": 5, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "last_status", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "last_value", + "position": 7, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "last_sample_count", + "position": 8, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "last_evaluated_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "last_error", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "last_error_kind", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rule_states", + "name": "updated_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "notes", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "notification_template_json", + "position": 4, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "enabled", + "position": 5, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "severity", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "service_names_json", + "position": 7, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "exclude_service_names_json", + "position": 8, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "environments_json", + "position": 9, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "anomaly_signals_json", + "position": 10, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "audit_filters_json", + "position": 11, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "audit_count_from", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "cost_budget_json", + "position": 13, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "tags_json", + "position": 14, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "signal_type", + "position": 15, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "comparator", + "position": 16, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "threshold", + "position": 17, + "type": "double precision", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "threshold_upper", + "position": 18, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "thresholds_json", + "position": 19, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "window_minutes", + "position": 20, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "evaluation_interval_minutes", + "position": 21, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "slowed_interval_minutes", + "position": 22, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "slowed_at", + "position": 23, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "minimum_sample_count", + "position": 24, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "consecutive_breaches_required", + "position": 25, + "type": "integer", + "notNull": true, + "default": "2", + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "breaches_out_of", + "position": 26, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "consecutive_healthy_required", + "position": 27, + "type": "integer", + "notNull": true, + "default": "2", + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "renotify_interval_minutes", + "position": 28, + "type": "integer", + "notNull": true, + "default": "30", + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "apdex_threshold_ms", + "position": 29, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "query_builder_draft_json", + "position": 30, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "raw_query_sql", + "position": 31, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "group_by", + "position": 32, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "destination_ids_json", + "position": 33, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "query_spec_json", + "position": 34, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "reducer", + "position": 35, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "sample_count_strategy", + "position": 36, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "no_data_behavior", + "position": 37, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "last_scheduled_at", + "position": 38, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "created_at", + "position": 39, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "updated_at", + "position": 40, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "created_by", + "position": 41, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_rules", + "name": "updated_by", + "position": 42, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "reason", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "matchers_json", + "position": 3, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "starts_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "ends_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "maintenance_window_id", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "exclude_from_baselines", + "position": 7, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "updated_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "created_by", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "alert_silences", + "name": "updated_by", + "position": 11, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_settings", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_settings", + "name": "enabled", + "position": 1, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_settings", + "name": "sensitivity", + "position": 2, + "type": "text", + "notNull": true, + "default": "'normal'", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_settings", + "name": "muted_signals_json", + "position": 3, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_settings", + "name": "last_tick_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_settings", + "name": "created_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_settings", + "name": "updated_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_settings", + "name": "updated_by", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "detector_key", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "signal_type", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "service_name", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "deployment_env", + "position": 4, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "fingerprint_hash", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "consecutive_breaches", + "position": 6, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "consecutive_healthy", + "position": 7, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "last_status", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "last_value", + "position": 9, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "baseline_median", + "position": 10, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "last_sample_count", + "position": 11, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "last_evaluated_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "open_incident_id", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "last_resolved_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "last_incident_id", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_detector_states", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "detector_key", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "signal_type", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "service_name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "deployment_env", + "position": 5, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "fingerprint_hash", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "error_issue_id", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "status", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "severity", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "opened_value", + "position": 10, + "type": "double precision", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "baseline_median", + "position": 11, + "type": "double precision", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "baseline_sigma", + "position": 12, + "type": "double precision", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "threshold_value", + "position": 13, + "type": "double precision", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "last_observed_value", + "position": 14, + "type": "double precision", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "last_sample_count", + "position": 15, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "first_triggered_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "last_triggered_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "resolved_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "resolve_reason", + "position": 19, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "triage_status", + "position": 20, + "type": "text", + "notNull": true, + "default": "'none'", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "dedupe_key", + "position": 21, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "fingerprints_json", + "position": 22, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "reopen_count", + "position": 23, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "last_reopened_at", + "position": 24, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "created_at", + "position": 25, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "anomaly_incidents", + "name": "updated_at", + "position": 26, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "description", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "key_hash", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "key_prefix", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "revoked", + "position": 6, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "revoked_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "last_used_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "expires_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "metadata_json", + "position": 10, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "scopes", + "position": 11, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "kind", + "position": 12, + "type": "text", + "notNull": true, + "default": "'standard'", + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "created_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "created_by", + "position": 14, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "api_keys", + "name": "created_by_email", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "account_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "modules", + "position": 4, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "granted_modules", + "position": 5, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "template_version", + "position": 6, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "verified_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "last_checked_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "last_check_error", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "check_lease_until", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "metric_stream", + "position": 11, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "metric_stream_changed_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "stream_secret_ciphertext", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "stream_secret_iv", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "stream_secret_tag", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "stream_secret_hash", + "position": 16, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "stream_last_received_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "stream_last_error", + "position": 18, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "created_by", + "position": 19, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "created_at", + "position": 20, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "aws_connections", + "name": "updated_at", + "position": 21, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "plan_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "subscription_started_at", + "position": 3, + "type": "bigint", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "canceled_at", + "position": 4, + "type": "bigint", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "snapshot_json", + "position": 5, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "rule_reason", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "model_read", + "position": 7, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "posted_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "created_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cancellation_reviews", + "name": "updated_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_identities", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_identities", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_identities", + "name": "connector", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_identities", + "name": "external_user_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_identities", + "name": "user_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_identities", + "name": "display_name", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_identities", + "name": "created_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "connector", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "external_workspace_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "settings", + "position": 5, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "credentials_ciphertext", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "credentials_iv", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "credentials_tag", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "alerts_enabled", + "position": 9, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "direct_messages_enabled", + "position": 10, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "assistant_enabled", + "position": 11, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "chat_workspaces", + "name": "created_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "device_code_hash", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "user_code_hash", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "device_name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "approved_org_id", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "approved_user_id", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "approved_roles", + "position": 5, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "approved_user_email", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "api_key_id", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "token_ciphertext", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "token_iv", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "token_tag", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "approved_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "denied_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "created_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cli_device_authorizations", + "name": "expires_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "account_id", + "position": 2, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "dataset", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "zone_id", + "position": 4, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "zone_name", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "enabled", + "position": 6, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "watermark_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "backfill_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "settings_json", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "settings_fetched_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "quantiles_available", + "position": 11, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "discovered_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "live_scripts_json", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "grant_call_cap", + "position": 14, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "last_success_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "last_error", + "position": 16, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "last_error_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "lease_until", + "position": 18, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "backoff_until", + "position": 19, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "backoff_streak", + "position": 20, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "backoff_reason", + "position": 21, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "created_at", + "position": 22, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_analytics_state", + "name": "updated_at", + "position": 23, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "http_traffic_enabled", + "position": 1, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "firewall_enabled", + "position": 2, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "dns_enabled", + "position": 3, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "workers_enabled", + "position": 4, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "queues_enabled", + "position": 5, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "durable_objects_enabled", + "position": 6, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "created_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "updated_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_feature_settings", + "name": "updated_by", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "account_id", + "position": 2, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "config_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "origin_host", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "origin_port", + "position": 6, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "origin_scheme", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "origin_database", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "origin_user", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "deleted_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "created_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_hyperdrive_configs", + "name": "updated_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "name", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "zone_name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "service_name", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "dataset", + "position": 6, + "type": "text", + "notNull": true, + "default": "'http_requests'", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "secret_ciphertext", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "secret_iv", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "secret_tag", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "secret_hash", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "enabled", + "position": 11, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "last_received_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "last_error", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "secret_rotated_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "created_by", + "position": 17, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_logpush_connectors", + "name": "updated_by", + "position": 18, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_zone_settings", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_zone_settings", + "name": "account_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_zone_settings", + "name": "watch_new_zones", + "position": 2, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_zone_settings", + "name": "zone_overrides", + "position": 3, + "type": "jsonb", + "notNull": true, + "default": "'{}'", + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_zone_settings", + "name": "created_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_zone_settings", + "name": "updated_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cloudflare_zone_settings", + "name": "updated_by", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "provider", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "secret_ciphertext", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "secret_iv", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "secret_tag", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "account_id", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "account_label", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "updated_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_connections", + "name": "updated_by", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "provider", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "connection_ref", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "account_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "enabled", + "position": 5, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "watermark_date", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "backfill_date", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "last_synced_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "last_settled_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "last_error", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "last_error_reason", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "lease_until", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "next_attempt_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "consecutive_failures", + "position": 14, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "requests_month", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "requests_count", + "position": 16, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "created_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "cost_sources", + "name": "updated_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "dashboard_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "widget_id", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "mode", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "token_hash", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "token_ciphertext", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "token_iv", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "token_tag", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "token_suffix", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "created_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "created_by", + "position": 11, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "updated_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "updated_by", + "position": 13, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_shares", + "name": "revoked_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "dashboard_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "version_number", + "position": 3, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "snapshot_json", + "position": 4, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "change_kind", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "change_summary", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "source_version_id", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboard_versions", + "name": "created_by", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboards", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboards", + "name": "id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboards", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboards", + "name": "payload_json", + "position": 3, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboards", + "name": "created_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboards", + "name": "updated_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboards", + "name": "created_by", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboards", + "name": "updated_by", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dashboards", + "name": "version", + "position": 8, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "repository_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "lockfile_path", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "ecosystem", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "package_name", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "advisory_id", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "aliases", + "position": 7, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "severity", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "summary", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "versions", + "position": 10, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "fixed_in", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "relation", + "position": 12, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "status", + "position": 13, + "type": "text", + "notNull": true, + "default": "'open'", + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "first_seen_scan_id", + "position": 14, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "last_seen_scan_id", + "position": 15, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "first_seen_sha", + "position": 16, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "last_seen_sha", + "position": 17, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "fixed_scan_id", + "position": 18, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "fixed_sha", + "position": 19, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "status_reason", + "position": 20, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "status_changed_by", + "position": 21, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "status_changed_at", + "position": 22, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "created_at", + "position": 23, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_findings", + "name": "updated_at", + "position": 24, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "scan_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "lockfile_path", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "ecosystem", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "package_name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "version", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "relation", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "advisory_id", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "aliases", + "position": 8, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "severity", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "summary", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scan_matches", + "name": "fixed_in", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "repository_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "commit_sha", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "ref", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "trigger", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "default_branch_head", + "position": 6, + "type": "boolean", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "status", + "position": 7, + "type": "text", + "notNull": true, + "default": "'running'", + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "lockfiles", + "position": 8, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "package_count", + "position": 9, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "vulnerable_count", + "position": 10, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "error", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "advisory_fingerprint", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "started_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "dependency_scans", + "name": "finished_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "user_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "installation_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "public_jwk", + "position": 4, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "jkt", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "roles", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "scopes", + "position": 7, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "attested", + "position": 8, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "attestation", + "position": 9, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "created_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "last_used_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "expires_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "hard_expires_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_credentials", + "name": "revoked_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_proof_replays", + "name": "key", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "device_proof_replays", + "name": "expires_at", + "position": 1, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "user_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "email", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "enabled", + "position": 4, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "opted_out_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "day_of_week", + "position": 6, + "type": "integer", + "notNull": true, + "default": "1", + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "timezone", + "position": 7, + "type": "text", + "notNull": true, + "default": "'UTC'", + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "send_hour", + "position": 8, + "type": "integer", + "notNull": true, + "default": "9", + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "namespaces_json", + "position": 9, + "type": "text", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "environments_json", + "position": 10, + "type": "text", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "last_sent_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "last_attempted_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "web_analytics_enabled", + "position": 13, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "web_analytics_opted_out_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "web_analytics_last_sent_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "web_analytics_last_attempted_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "created_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "digest_subscriptions", + "name": "updated_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "fingerprint_hash", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "service_name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "exception_type", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "exception_message", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "error_label", + "position": 5, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "top_frame", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "service_versions_json", + "position": 7, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "occurrence_count", + "position": 8, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "first_seen_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "last_seen_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_fingerprint_candidates", + "name": "updated_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "issue_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "status", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "reason", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "first_triggered_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "last_triggered_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "resolved_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "occurrence_count", + "position": 8, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "created_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_incidents", + "name": "updated_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_events", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_events", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_events", + "name": "issue_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_events", + "name": "actor_id", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_events", + "name": "type", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_events", + "name": "from_state", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_events", + "name": "to_state", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_events", + "name": "payload_json", + "position": 7, + "type": "jsonb", + "notNull": true, + "default": "'{}'", + "identity": null + }, + { + "kind": "column", + "table": "error_issue_events", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_fingerprints", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_fingerprints", + "name": "fingerprint_hash", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_fingerprints", + "name": "issue_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_fingerprints", + "name": "source", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_fingerprints", + "name": "origin_issue_id", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_fingerprints", + "name": "created_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "issue_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "provider", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "external_repo_id", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "repo_full_name", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "number", + "position": 6, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "url", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "title", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "author_login", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "state", + "position": 10, + "type": "text", + "notNull": true, + "default": "'open'", + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "merged_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "merge_commit_sha", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "link_source", + "position": 13, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "linked_by_actor_id", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_pull_requests", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_states", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_states", + "name": "issue_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_states", + "name": "last_observed_occurrence_at", + "position": 2, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_states", + "name": "last_evaluated_at", + "position": 3, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_states", + "name": "open_incident_id", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_states", + "name": "updated_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "issue_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "pull_request_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "status", + "position": 4, + "type": "text", + "notNull": true, + "default": "'waiting'", + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "merged_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "verify_after", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "baseline_versions_json", + "position": 7, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "baseline_occurrence_count", + "position": 8, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "baseline_rate_per_hour", + "position": 9, + "type": "double precision", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "investigation_id", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "verdict", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "verdict_note", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "post_merge_occurrence_count", + "position": 13, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "attempt", + "position": 14, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issue_verifications", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "kind", + "position": 2, + "type": "text", + "notNull": true, + "default": "'error'", + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "source_ref_json", + "position": 3, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "fingerprint_hash", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "fingerprint_version", + "position": 5, + "type": "integer", + "notNull": true, + "default": "1", + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "service_name", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "exception_type", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "exception_message", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "error_label", + "position": 9, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "top_frame", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "workflow_state", + "position": 11, + "type": "text", + "notNull": true, + "default": "'triage'", + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "priority", + "position": 12, + "type": "integer", + "notNull": true, + "default": "3", + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "severity", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "severity_source", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "assigned_actor_id", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "lease_holder_actor_id", + "position": 16, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "lease_expires_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "claimed_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "notes", + "position": 19, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "first_seen_at", + "position": 20, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "last_seen_at", + "position": 21, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "occurrence_count", + "position": 22, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "resolved_at", + "position": 23, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "resolved_by_actor_id", + "position": 24, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "last_resolved_at", + "position": 25, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "last_regressed_at", + "position": 26, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "regression_count", + "position": 27, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "seen_versions_json", + "position": 28, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "resolved_versions_json", + "position": 29, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "snooze_until", + "position": 30, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "archived_at", + "position": 31, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "merged_into_issue_id", + "position": 32, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "created_at", + "position": 33, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_issues", + "name": "updated_at", + "position": 34, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "destination_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "delivery_key", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "payload_json", + "position": 4, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "status", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "attempt_count", + "position": 6, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "scheduled_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "claimed_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "claim_expires_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "claimed_by", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "attempted_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "error_message", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "created_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_deliveries", + "name": "updated_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "enabled", + "position": 1, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "destination_ids_json", + "position": 2, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "notify_on_first_seen", + "position": 3, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "notify_on_regression", + "position": 4, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "notify_on_resolve", + "position": 5, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "notify_on_transition_in_review", + "position": 6, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "notify_on_transition_done", + "position": 7, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "notify_on_claim", + "position": 8, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "min_occurrence_count", + "position": 9, + "type": "integer", + "notNull": true, + "default": "1", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "severity", + "position": 10, + "type": "text", + "notNull": true, + "default": "'warning'", + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "updated_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_notification_policies", + "name": "updated_by", + "position": 12, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_tick_states", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_tick_states", + "name": "processed_through", + "position": 1, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_tick_states", + "name": "bootstrap_completed", + "position": 2, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "error_tick_states", + "name": "claim_token", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_tick_states", + "name": "claim_expires_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "error_tick_states", + "name": "updated_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "description", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "steps_json", + "position": 4, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "repeat_count", + "position": 5, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "created_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "updated_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "created_by", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "escalation_chains", + "name": "updated_by", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "source_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "kind", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "row_estimate", + "position": 4, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "source_note", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "detected_time_field", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "fields", + "position": 7, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "exposed", + "position": 8, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "note", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "time_field_override", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "field_notes", + "position": 11, + "type": "jsonb", + "notNull": true, + "default": "'{}'::jsonb", + "identity": null + }, + { + "kind": "column", + "table": "external_data_source_catalog_entries", + "name": "seen_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "kind", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "description", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "environment", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "tags", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": "'[]'::jsonb", + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "agent_access", + "position": 7, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "agent_pii", + "position": 8, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "config", + "position": 9, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "secret_ciphertext", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "secret_iv", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "secret_tag", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "secret_hint", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "status", + "position": 14, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "last_checked_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "last_error", + "position": 16, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "catalog_refreshed_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "catalog_error", + "position": 18, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "examples", + "position": 19, + "type": "jsonb", + "notNull": true, + "default": "'[]'::jsonb", + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "created_at", + "position": 20, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "updated_at", + "position": 21, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "created_by", + "position": 22, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "external_data_sources", + "name": "updated_by", + "position": 23, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "scope_type", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "scope_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "project_id", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "logs_enabled", + "position": 6, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "metrics_enabled", + "position": 7, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "secret_ciphertext", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "secret_iv", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "secret_tag", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "secret_hash", + "position": 11, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "last_received_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "last_error", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "applied_logs_enabled", + "position": 14, + "type": "boolean", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "applied_metrics_enabled", + "position": 15, + "type": "boolean", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "setup_reported_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "metrics_watermark_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "last_metrics_received_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "last_metrics_error", + "position": 19, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "metrics_lease_until", + "position": 20, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "metrics_hold_until", + "position": 21, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "metrics_polled_at", + "position": 22, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "resources_synced_at", + "position": 23, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "last_resources_error", + "position": 24, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "created_by", + "position": 25, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "created_at", + "position": 26, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_connectors", + "name": "updated_at", + "position": 27, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "connector_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "asset_type", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "project_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "location", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "display_name", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "state", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "labels", + "position": 8, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "details", + "position": 9, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "resource_created_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "resource_updated_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "gcp_resources", + "name": "last_seen_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "status", + "position": 2, + "type": "text", + "notNull": true, + "default": "'investigating'", + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "seeded_by", + "position": 3, + "type": "text", + "notNull": true, + "default": "'user'", + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "subject_json", + "position": 4, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "snapshot_json", + "position": 5, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "incident_kind", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "incident_id", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "issue_id", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "report_json", + "position": 9, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "progress_json", + "position": 10, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "severity", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "confidence", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "model", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "input_tokens", + "position": 14, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "output_tokens", + "position": 15, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "error", + "position": 16, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "started_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "autonomous_turns", + "position": 18, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "created_by", + "position": 19, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "created_at", + "position": 20, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "diagnosed_at", + "position": 21, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "investigations", + "name": "updated_at", + "position": 22, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalation_policies", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalation_policies", + "name": "enabled", + "position": 1, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "issue_escalation_policies", + "name": "rules_json", + "position": 2, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "issue_escalation_policies", + "name": "updated_at", + "position": 3, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalation_policies", + "name": "updated_by", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "issue_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "severity", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "source", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "reason", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "run_id", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "investigation_id", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "payload_json", + "position": 8, + "type": "jsonb", + "notNull": true, + "default": "'{}'", + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "delivery_results_json", + "position": 9, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "status", + "position": 10, + "type": "text", + "notNull": true, + "default": "'queued'", + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "attempts", + "position": 11, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "claimed_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "dedupe_key", + "position": 13, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "error", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "issue_escalations", + "name": "processed_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "linear_feature_settings", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "linear_feature_settings", + "name": "open_issues_enabled", + "position": 1, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "linear_feature_settings", + "name": "update_comments_enabled", + "position": 2, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "linear_feature_settings", + "name": "reopen_issues_enabled", + "position": 3, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "linear_feature_settings", + "name": "resolve_comments_enabled", + "position": 4, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "linear_feature_settings", + "name": "created_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "linear_feature_settings", + "name": "updated_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "linear_feature_settings", + "name": "updated_by", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "device_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "incident_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "activity_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "push_token", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "ended_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "ended_reason", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "live_activities", + "name": "updated_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "request_id_hash", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "client_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "client_name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "redirect_uri", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "state", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "resource", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "scopes", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "code_challenge", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "authorization_code_hash", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "approved_org_id", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "approved_user_id", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "approved_roles", + "position": 11, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "approved_user_email", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "approved_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "denied_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "used_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "created_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_authorizations", + "name": "expires_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_clients", + "name": "client_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_clients", + "name": "client_name", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_clients", + "name": "redirect_uris", + "position": 2, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_clients", + "name": "client_uri", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_clients", + "name": "created_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "token_hash", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "family_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "client_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "resource", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "scopes", + "position": 5, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "org_id", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "user_id", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "roles", + "position": 8, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "user_email", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "access_key_id", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "replaced_by_id", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "revoked_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "created_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "expires_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mcp_oauth_refresh_tokens", + "name": "family_expires_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "user_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "platform", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "token", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "environment", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "bundle_id", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "app_version", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "live_activity_start_token", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "device_name", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "preferences", + "position": 10, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "disabled_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "disabled_reason", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "last_pushed_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "last_seen_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "mobile_devices", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "state", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "provider", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "initiated_by_user_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "redirect_uri", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "return_to", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "code_verifier", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "github_installation_ids", + "position": 7, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_auth_states", + "name": "expires_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "provider", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "external_user_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "external_user_email", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "external_account_name", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "granted_accounts_json", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "connected_by_user_id", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "scope", + "position": 9, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "access_token_ciphertext", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "access_token_iv", + "position": 11, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "access_token_tag", + "position": 12, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "refresh_token_ciphertext", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "refresh_token_iv", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "refresh_token_tag", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "expires_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "revoked_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "created_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oauth_connections", + "name": "updated_at", + "position": 19, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_overrides", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_overrides", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_overrides", + "name": "schedule_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_overrides", + "name": "user_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_overrides", + "name": "starts_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_overrides", + "name": "ends_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_overrides", + "name": "created_by", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_overrides", + "name": "created_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "description", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "time_zone", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "layers_json", + "position": 5, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "created_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "updated_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "created_by", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "oncall_schedules", + "name": "updated_by", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "key_ciphertext", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "key_iv", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "key_tag", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "key_label", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "account_id", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "created_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "updated_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "openrouter_cost_connections", + "name": "updated_by", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_billing_links", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_billing_links", + "name": "billing_org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_billing_links", + "name": "linked_by", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_billing_links", + "name": "created_at", + "position": 3, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "workflow_instance_id", + "position": 1, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "status", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "phase", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "current_migration", + "position": 4, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "steps_total", + "position": 5, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "steps_done", + "position": 6, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "applied_versions", + "position": 7, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "skipped", + "position": 8, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "error_message", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "started_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "finished_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "created_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_schema_apply_runs", + "name": "updated_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "ch_url", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "ch_user", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "ch_password_ciphertext", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "ch_password_iv", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "ch_password_tag", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "ch_database", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "sync_status", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "last_sync_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "last_sync_error", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "schema_version", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "created_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "updated_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "created_by", + "position": 13, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_clickhouse_settings", + "name": "updated_by", + "position": 14, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_directory_groups", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_directory_groups", + "name": "directory_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_directory_groups", + "name": "group_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_directory_groups", + "name": "display_name", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_directory_groups", + "name": "updated_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_directory_groups", + "name": "deleted_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "source_context", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "source_key", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "target_key", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "operation", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "enabled", + "position": 7, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": "now()", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_attribute_mappings", + "name": "updated_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": "now()", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "public_key", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "public_key_hash", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "private_key_ciphertext", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "private_key_iv", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "private_key_tag", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "private_key_hash", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "public_rotated_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "private_rotated_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "created_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "updated_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "created_by", + "position": 11, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_keys", + "name": "updated_by", + "position": 12, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_settings", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_settings", + "name": "hash_salt", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_settings", + "name": "created_at", + "position": 2, + "type": "timestamp with time zone", + "notNull": true, + "default": "now()", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_stats", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_stats", + "name": "rule_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_stats", + "name": "bucket", + "position": 2, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_stats", + "name": "signal", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_stats", + "name": "matched", + "position": 4, + "type": "bigint", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_stats", + "name": "dropped", + "position": 5, + "type": "bigint", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_stats", + "name": "dropped_bytes", + "position": 6, + "type": "bigint", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rule_stats", + "name": "redacted_values", + "position": 7, + "type": "bigint", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rules", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rules", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rules", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rules", + "name": "enabled", + "position": 3, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rules", + "name": "position", + "position": 4, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rules", + "name": "spec_json", + "position": 5, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rules", + "name": "created_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": "now()", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_rules", + "name": "updated_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": "now()", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_sampling_policies", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_sampling_policies", + "name": "trace_sample_ratio", + "position": 1, + "type": "double precision", + "notNull": true, + "default": "1", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_sampling_policies", + "name": "always_keep_error_spans", + "position": 2, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_sampling_policies", + "name": "always_keep_slow_spans_ms", + "position": 3, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_sampling_policies", + "name": "created_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": true, + "default": "now()", + "identity": null + }, + { + "kind": "column", + "table": "org_ingest_sampling_policies", + "name": "updated_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": "now()", + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "user_id", + "position": 1, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "email", + "position": 2, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "role", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "demo_data_requested", + "position": 4, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "onboarding_completed_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "checklist_dismissed_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "first_data_received_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "welcome_email_sent_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "connect_nudge_email_sent_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "stalled_email_sent_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "activation_email_sent_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "reward_claimed_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "reward_reserved_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "created_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_onboarding_state", + "name": "updated_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_openrouter_keys", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_openrouter_keys", + "name": "key_ciphertext", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_openrouter_keys", + "name": "key_iv", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_openrouter_keys", + "name": "key_tag", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_openrouter_keys", + "name": "key_hint", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_openrouter_keys", + "name": "created_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_openrouter_keys", + "name": "updated_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_openrouter_keys", + "name": "updated_by", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "number", + "position": 2, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "recommendation_key", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "kind", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "source_key", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "canonical_key", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "status", + "position": 7, + "type": "text", + "notNull": true, + "default": "'open'", + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "usage_count", + "position": 8, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "opened_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": "now()", + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "updated_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": "now()", + "identity": null + }, + { + "kind": "column", + "table": "org_recommendation_issues", + "name": "resolved_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_connections", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_connections", + "name": "clerk_connection_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_connections", + "name": "clerk_directory_id", + "position": 2, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_connections", + "name": "created_at", + "position": 3, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_connections", + "name": "created_by", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_connections", + "name": "updated_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_domains", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_domains", + "name": "domain", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_domains", + "name": "challenge", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_domains", + "name": "status", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_domains", + "name": "clerk_domain_id", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_domains", + "name": "verified_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_domains", + "name": "created_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_sso_domains", + "name": "created_by", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_support_channels", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_support_channels", + "name": "slack_channel_id", + "position": 1, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_support_channels", + "name": "slack_channel_name", + "position": 2, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_support_channels", + "name": "reservation_id", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_support_channels", + "name": "reserved_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_support_channels", + "name": "created_by_user_id", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_support_channels", + "name": "created_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "org_support_channels", + "name": "updated_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "ps_organization", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "connected_by_user_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "scrape_target_id", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "webhook_secret_ciphertext", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "webhook_secret_iv", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "webhook_secret_tag", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "detected_permissions_json", + "position": 9, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "metrics_enabled", + "position": 10, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "events_enabled", + "position": 11, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "last_inventory_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "last_inventory_error", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "created_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_connections", + "name": "updated_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "database_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "name", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "kind", + "position": 4, + "type": "text", + "notNull": true, + "default": "'mysql'", + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "state", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "region", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "plan", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "branches_json", + "position": 8, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "webhook_id", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "webhook_secret_ciphertext", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "webhook_secret_iv", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "webhook_secret_tag", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "webhook_error", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "deleted_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_databases", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "database_id", + "position": 2, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "database_name", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "branch_name", + "position": 4, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "category", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "event_type", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "state", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "external_id", + "position": 8, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "title", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "source", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "actor_login", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "url", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "payload_json", + "position": 13, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "occurred_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_events", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_issue_receipts", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_issue_receipts", + "name": "event_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_issue_receipts", + "name": "processed_at", + "position": 2, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "dataset", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "database_id", + "position": 3, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "enabled", + "position": 4, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "watermark_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "last_success_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "last_error", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "last_error_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "lease_until", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "hold_until", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "created_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "planetscale_poll_state", + "name": "updated_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_edits", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_edits", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_edits", + "name": "reply_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_edits", + "name": "seq", + "position": 3, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_edits", + "name": "path", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_edits", + "name": "old_text", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_edits", + "name": "new_text", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_edits", + "name": "created_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_finding_embeddings", + "name": "finding_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_finding_embeddings", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_finding_embeddings", + "name": "repository_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_finding_embeddings", + "name": "model", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_finding_embeddings", + "name": "embedding", + "position": 4, + "type": "real[]", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_finding_embeddings", + "name": "created_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "repository_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "number", + "position": 3, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "review_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "handle", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "path", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "line", + "position": 7, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "category", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "severity", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "title", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "status", + "position": 11, + "type": "text", + "notNull": true, + "default": "'open'", + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "comment_id", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "resolved_sha", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "reactions_up", + "position": 14, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "reactions_down", + "position": 15, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "created_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_findings", + "name": "updated_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "repository_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "number", + "position": 3, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "key", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "kind", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "title", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "source", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "path", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "status", + "position": 9, + "type": "text", + "notNull": true, + "default": "'open'", + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "done_by", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "done_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "reminded_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "first_review_id", + "position": 13, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "last_review_id", + "position": 14, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_merge_steps", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "repository_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "number", + "position": 3, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "comment_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "surface", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "thread_root_id", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "author_login", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "command", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "head_sha", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "status", + "position": 10, + "type": "text", + "notNull": true, + "default": "'queued'", + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "session_id", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "reply_url", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "commit_sha", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "error", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_replies", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_settings", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_settings", + "name": "model", + "position": 1, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_settings", + "name": "defaults", + "position": 2, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_settings", + "name": "updated_at", + "position": 3, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_review_settings", + "name": "updated_by", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "repository_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "number", + "position": 3, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "head_sha", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "base_sha", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "url", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "title", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "author_login", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "status", + "position": 9, + "type": "text", + "notNull": true, + "default": "'queued'", + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "skip_reason", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "session_id", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "comment_attempt", + "position": 12, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "report_json", + "position": 13, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "score", + "position": 14, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "check_run_url", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "comment_url", + "position": 16, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "review_url", + "position": 17, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "publish_error", + "position": 18, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "error", + "position": 19, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "model", + "position": 20, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "input_tokens", + "position": 21, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "output_tokens", + "position": 22, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "cost_microusd", + "position": 23, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "started_at", + "position": 24, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "finished_at", + "position": 25, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "merged_at", + "position": 26, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "telemetry_json", + "position": 27, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "merge_commit_sha", + "position": 28, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "post_merge_status", + "position": 29, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "post_merge_after", + "position": 30, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "post_merge_json", + "position": 31, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "created_at", + "position": 32, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "pr_reviews", + "name": "updated_at", + "position": 33, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "token_ciphertext", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "token_iv", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "token_tag", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "workspace_names", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "connected_by_user_id", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "auth_failed_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "discovered_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "lease_until", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "hold_until", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "last_success_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "last_error", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "last_error_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_connections", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "connection_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "project_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "project_name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "environment_id", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "environment_name", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "services_json", + "position": 7, + "type": "text", + "notNull": true, + "default": "'{}'", + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "enabled", + "position": 8, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "watermark_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "last_success_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "last_error", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "last_error_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "created_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "railway_environments", + "name": "updated_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "saved_views", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "saved_views", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "saved_views", + "name": "owner_user_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "saved_views", + "name": "surface", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "saved_views", + "name": "name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "saved_views", + "name": "state", + "position": 5, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "saved_views", + "name": "visibility", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "saved_views", + "name": "created_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "saved_views", + "name": "updated_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_target_checks", + "name": "id", + "position": 0, + "type": "integer", + "notNull": true, + "default": null, + "identity": "by default" + }, + { + "kind": "column", + "table": "scrape_target_checks", + "name": "target_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_target_checks", + "name": "org_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_target_checks", + "name": "sub_target_key", + "position": 3, + "type": "text", + "notNull": true, + "default": "''", + "identity": null + }, + { + "kind": "column", + "table": "scrape_target_checks", + "name": "checked_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_target_checks", + "name": "error", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_target_checks", + "name": "duration_ms", + "position": 6, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_target_checks", + "name": "samples_scraped", + "position": 7, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_target_checks", + "name": "samples_post_relabel", + "position": 8, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "name", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "service_name", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "url", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "target_type", + "position": 6, + "type": "text", + "notNull": true, + "default": "'prometheus'", + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "discovery_config_json", + "position": 7, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "scrape_interval_seconds", + "position": 8, + "type": "integer", + "notNull": true, + "default": "15", + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "labels_json", + "position": 9, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "auth_type", + "position": 10, + "type": "text", + "notNull": true, + "default": "'none'", + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "managed_by", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "auth_credentials_ciphertext", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "auth_credentials_iv", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "auth_credentials_tag", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "enabled", + "position": 15, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "last_scrape_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "last_scrape_error", + "position": 17, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "created_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "scrape_targets", + "name": "updated_at", + "position": 19, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "oauth_connection_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "site_url", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "permission_level", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "enabled", + "position": 5, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "watermark_date", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "backfill_date", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "last_synced_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "last_error", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "lease_until", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "next_attempt_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "consecutive_failures", + "position": 12, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "created_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "search_console_sites", + "name": "updated_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "run_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "org_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "at", + "position": 3, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "kind", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "role", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "agent_id", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "outcome", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "detail", + "position": 8, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "input_tokens", + "position": 9, + "type": "bigint", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_events", + "name": "output_tokens", + "position": 10, + "type": "bigint", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "target_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "fingerprint", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "verdict", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "overall_severity", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "estimated_severity", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "record", + "position": 7, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "status", + "position": 8, + "type": "text", + "notNull": true, + "default": "'open'", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "first_seen_run_id", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "last_seen_run_id", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "first_seen_ref", + "position": 11, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "last_seen_ref", + "position": 12, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "fixed_run_id", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "status_reason", + "position": 14, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "status_changed_by", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "status_changed_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "created_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_findings", + "name": "updated_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_reservations", + "name": "run_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_reservations", + "name": "agent_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_reservations", + "name": "org_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_reservations", + "name": "cost_usd", + "position": 3, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_reservations", + "name": "sandbox_fee_usd", + "position": 4, + "type": "double precision", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_reservations", + "name": "created_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_settings", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_settings", + "name": "monthly_spend_limit_usd", + "position": 1, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_settings", + "name": "discovery_model", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_settings", + "name": "validation_model", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_settings", + "name": "updated_by", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_org_settings", + "name": "updated_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_run_findings", + "name": "run_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_run_findings", + "name": "fingerprint", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_run_findings", + "name": "org_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_run_findings", + "name": "verdict", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_run_findings", + "name": "overall_severity", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_run_findings", + "name": "estimated_severity", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_run_findings", + "name": "record", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "target_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "kind", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "source_ref", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "profile", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "scope_paths", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "budget", + "position": 7, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "metadata", + "position": 8, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "status", + "position": 9, + "type": "text", + "notNull": true, + "default": "'in_progress'", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "incomplete_reason", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "architecture_md", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "reports", + "position": 12, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "execution_profile", + "position": 13, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "invocations_spent", + "position": 14, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "input_tokens", + "position": 15, + "type": "bigint", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "output_tokens", + "position": 16, + "type": "bigint", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "cost_usd", + "position": 17, + "type": "double precision", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "sandbox_usd", + "position": 18, + "type": "double precision", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "discovery_model", + "position": 19, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "validation_model", + "position": 20, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "workflow_instance_id", + "position": 21, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "started_at", + "position": 22, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "finished_at", + "position": 23, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_runs", + "name": "error", + "position": 24, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "repository", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "vcs_repository_id", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "branch", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "enabled", + "position": 5, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "profile", + "position": 6, + "type": "text", + "notNull": true, + "default": "'deep'", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "scope_paths", + "position": 7, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "slice_interval_hours", + "position": 8, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "revalidate_on_push", + "position": 9, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "budget_per_run", + "position": 10, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "monthly_invocation_budget", + "position": 11, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "discovery_model", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "validation_model", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "created_by", + "position": 14, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_targets", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_units", + "name": "run_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_units", + "name": "coverage_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_units", + "name": "org_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_units", + "name": "status", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_units", + "name": "wave", + "position": 4, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_units", + "name": "agent_id", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "security_audit_units", + "name": "unit", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "service_map_world_entities", + "name": "org_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "service_map_world_entities", + "name": "entity_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "service_map_world_entities", + "name": "kind", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "service_map_world_entities", + "name": "data", + "position": 3, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "service_map_world_entities", + "name": "revision", + "position": 4, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "service_map_world_entities", + "name": "created_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "service_map_world_entities", + "name": "updated_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "service_map_world_entities", + "name": "updated_by", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "service_map_world_entities", + "name": "deleted_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "description", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "service_name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "environments_json", + "position": 5, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "sli_json", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "target_percent", + "position": 7, + "type": "double precision", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "window_days", + "position": 8, + "type": "integer", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "alert_rule_id", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "created_by", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "updated_by", + "position": 11, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "created_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "slos", + "name": "updated_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "description", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "platform", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "kind", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "key_hash", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "key_prefix", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "allowed_signals", + "position": 8, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "rate_limit_rps", + "position": 9, + "type": "integer", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "resource_attributes", + "position": 10, + "type": "jsonb", + "notNull": true, + "default": "'[]'::jsonb", + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "expires_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "paused_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "paused_until", + "position": 13, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "last_used_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "last_rejected_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "last_rejection", + "position": 16, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "last_poll_at", + "position": 17, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "last_poll_ok_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "last_poll_error", + "position": 19, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "disconnected_at", + "position": 20, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "poll_resources", + "position": 21, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "rolled_at", + "position": 22, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "created_at", + "position": 23, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "updated_at", + "position": 24, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "created_by", + "position": 25, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "sources", + "name": "updated_by", + "position": 26, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_cleanups", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_cleanups", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_cleanups", + "name": "page_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_cleanups", + "name": "slug", + "position": 3, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_cleanups", + "name": "delete_snapshot", + "position": 4, + "type": "boolean", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_cleanups", + "name": "hostname", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_cleanups", + "name": "cloudflare_hostname_id", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_cleanups", + "name": "cloudflare_route_id", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_cleanups", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "page_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "name", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "description", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "group_name", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "position", + "position": 6, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "monitor_id", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "manual_status", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "show_uptime", + "position": 9, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "created_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_components", + "name": "updated_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "page_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "hostname", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "status", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "cloudflare_hostname_id", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "cloudflare_route_id", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "dns_records", + "position": 6, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "last_error", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "last_checked_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "activated_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "created_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_custom_domains", + "name": "updated_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_components", + "name": "incident_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_components", + "name": "component_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_components", + "name": "org_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_updates", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_updates", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_updates", + "name": "incident_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_updates", + "name": "status", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_updates", + "name": "body", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_updates", + "name": "source", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_updates", + "name": "created_by", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_updates", + "name": "overlay_entry_id", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incident_updates", + "name": "created_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "page_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "kind", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "title", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "impact", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "status", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "published", + "position": 7, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "alert_incident_id", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "scheduled_start", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "scheduled_end", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "started_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "resolved_at", + "position": 12, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "created_by", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "created_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_page_incidents", + "name": "updated_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "slug", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "description", + "position": 4, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "website_url", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "logo_url", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "logo_dark_url", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "favicon_url", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "support_url", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "privacy_url", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "terms_url", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "theme", + "position": 12, + "type": "jsonb", + "notNull": true, + "default": "'{\"preset\":\"default\",\"appearance\":\"auto\",\"accent\":null,\"background\":null,\"text\":null,\"card\":null,\"border\":null,\"radius\":\"md\",\"font\":\"sans\"}'", + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "show_powered_by", + "position": 13, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "auto_incidents", + "position": 14, + "type": "text", + "notNull": true, + "default": "'off'", + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "break_glass_token_sha256", + "position": 15, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "break_glass_token_suffix", + "position": 16, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "visibility", + "position": 17, + "type": "text", + "notNull": true, + "default": "'public'", + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "password_hash", + "position": 18, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "draft", + "position": 19, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "revision", + "position": 20, + "type": "bigint", + "notNull": true, + "default": "1", + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "published_revision", + "position": 21, + "type": "bigint", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "published_at", + "position": 22, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "last_publish_error", + "position": 23, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "published_hash", + "position": 24, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "publish_attempted_at", + "position": 25, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "created_by", + "position": 26, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "created_at", + "position": 27, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "status_pages", + "name": "updated_at", + "position": 28, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "supabase_organization_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "supabase_organization_slug", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "supabase_organization_name", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "connected_by_user_id", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "discovery_lease_until", + "position": 7, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "last_discovery_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "last_discovery_error", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "created_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_connections", + "name": "updated_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "project_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "advisors_json", + "position": 2, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "top_queries_json", + "position": 3, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "advisors_checked_at", + "position": 4, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "queries_checked_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "advisors_error", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "queries_error", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "lease_until", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "hold_until", + "position": 9, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "created_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_project_insights", + "name": "updated_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "connection_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "project_ref", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "region", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "status", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "metrics_enabled", + "position": 7, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "scrape_target_id", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "log_drain_enabled", + "position": 9, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "log_drain_id", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "log_drain_source_id", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "log_drain_error", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "log_drains_json", + "position": 13, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "log_drains_checked_at", + "position": 14, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "logs_enabled", + "position": 15, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "logs_watermark_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "logs_boundary_ids", + "position": 17, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "logs_lease_until", + "position": 18, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "logs_hold_until", + "position": 19, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "logs_last_polled_at", + "position": 20, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "logs_error", + "position": 21, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "last_seen_at", + "position": 22, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "removed_at", + "position": 23, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "created_at", + "position": 24, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "supabase_projects", + "name": "updated_at", + "position": 25, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_daily", + "name": "monitor_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_daily", + "name": "day", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_daily", + "name": "org_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_daily", + "name": "checks", + "position": 3, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_daily", + "name": "failures", + "position": 4, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_daily", + "name": "down_checks", + "position": 5, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_daily", + "name": "last_check_at", + "position": 6, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "monitor_id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "status", + "position": 2, + "type": "text", + "notNull": true, + "default": "'pending'", + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "consecutive_failures", + "position": 3, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "consecutive_successes", + "position": 4, + "type": "integer", + "notNull": true, + "default": "0", + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "status_changed_at", + "position": 5, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "last_check_json", + "position": 6, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "recent_json", + "position": 7, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "last_ping_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitor_states", + "name": "updated_at", + "position": 9, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "name", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "kind", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "config_json", + "position": 4, + "type": "jsonb", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "headers_ciphertext", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "headers_iv", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "headers_tag", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "interval_seconds", + "position": 8, + "type": "integer", + "notNull": true, + "default": "60", + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "failures_to_down", + "position": 9, + "type": "integer", + "notNull": true, + "default": "2", + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "service_name", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "alert_rule_id", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "heartbeat_token", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "enabled", + "position": 13, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "created_by", + "position": 14, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "uptime_monitors", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "provider", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "repository_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "sha", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "message", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "author_name", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "author_email", + "position": 7, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "author_login", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "author_avatar_url", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "authored_at", + "position": 10, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "committed_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "html_url", + "position": 12, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_commits", + "name": "created_at", + "position": 13, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "provider", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "external_installation_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "account_login", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "account_type", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "external_account_id", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "account_avatar_url", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "repository_selection", + "position": 9, + "type": "text", + "notNull": true, + "default": "'all'", + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "status", + "position": 10, + "type": "text", + "notNull": true, + "default": "'active'", + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "suspended_at", + "position": 11, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "ci_traces_enabled", + "position": 12, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "repository_discovery", + "position": 13, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "installed_by_user_id", + "position": 14, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "created_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_installations", + "name": "updated_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "provider", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "installation_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "external_repo_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "owner", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "name", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "full_name", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "default_branch", + "position": 8, + "type": "text", + "notNull": true, + "default": "'main'", + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "tracked_branch", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "html_url", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "is_private", + "position": 11, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "is_archived", + "position": 12, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "status", + "position": 13, + "type": "text", + "notNull": true, + "default": "'active'", + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "sync_status", + "position": 14, + "type": "text", + "notNull": true, + "default": "'pending'", + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "last_synced_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "last_sync_error", + "position": 16, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "pr_review_enabled", + "position": 17, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "pr_review_config", + "position": 18, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "created_at", + "position": 19, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repositories", + "name": "updated_at", + "position": 20, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repository_branches", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repository_branches", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repository_branches", + "name": "provider", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repository_branches", + "name": "repository_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repository_branches", + "name": "name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repository_branches", + "name": "is_default", + "position": 5, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "vcs_repository_branches", + "name": "head_sha", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repository_branches", + "name": "created_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vcs_repository_branches", + "name": "updated_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "source_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "team_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "team_slug", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "team_name", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "token_ciphertext", + "position": 6, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "token_iv", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "token_tag", + "position": 8, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "connected_by_user_id", + "position": 9, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "project_scope", + "position": 10, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "project_ids", + "position": 11, + "type": "jsonb", + "notNull": true, + "default": "'[]'", + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "sampling_rate", + "position": 12, + "type": "double precision", + "notNull": true, + "default": "1", + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "logs_enabled", + "position": 13, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "traces_enabled", + "position": 14, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "ai_gateway_enabled", + "position": 15, + "type": "boolean", + "notNull": true, + "default": "true", + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "speed_insights_enabled", + "position": 16, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "web_analytics_enabled", + "position": 17, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "audit_log_enabled", + "position": 18, + "type": "boolean", + "notNull": true, + "default": "false", + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "log_drain_id", + "position": 19, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "trace_drain_id", + "position": 20, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "ai_gateway_drain_id", + "position": 21, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "speed_insights_drain_id", + "position": 22, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "web_analytics_drain_id", + "position": 23, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "audit_log_drain_id", + "position": 24, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "log_drain_state", + "position": 25, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "trace_drain_state", + "position": 26, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "ai_gateway_drain_state", + "position": 27, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "speed_insights_drain_state", + "position": 28, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "web_analytics_drain_state", + "position": 29, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "audit_log_drain_state", + "position": 30, + "type": "jsonb", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "drain_key_hash", + "position": 31, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "auth_failed_at", + "position": 32, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "discovered_at", + "position": 33, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "deployments_watermark_at", + "position": 34, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "lease_until", + "position": 35, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "hold_until", + "position": 36, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "last_success_at", + "position": 37, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "last_error", + "position": 38, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "last_error_at", + "position": 39, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "created_at", + "position": 40, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_connections", + "name": "updated_at", + "position": 41, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "connection_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "project_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "deployment_id", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "url", + "position": 5, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "target", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "state", + "position": 7, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "branch", + "position": 8, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "commit_sha", + "position": 9, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "commit_message", + "position": 10, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "creator", + "position": 11, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "error_code", + "position": 12, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "error_message", + "position": 13, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "created_at_vercel", + "position": 14, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "building_at", + "position": 15, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "ready_at", + "position": 16, + "type": "timestamp with time zone", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "inspector_url", + "position": 17, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_deployments", + "name": "updated_at", + "position": 18, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_projects", + "name": "id", + "position": 0, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_projects", + "name": "org_id", + "position": 1, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_projects", + "name": "connection_id", + "position": 2, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_projects", + "name": "project_id", + "position": 3, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_projects", + "name": "name", + "position": 4, + "type": "text", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_projects", + "name": "framework", + "position": 5, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_projects", + "name": "production_deployment_id", + "position": 6, + "type": "text", + "notNull": false, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_projects", + "name": "created_at", + "position": 7, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "column", + "table": "vercel_projects", + "name": "updated_at", + "position": 8, + "type": "timestamp with time zone", + "notNull": true, + "default": null, + "identity": null + }, + { + "kind": "index", + "table": "actors", + "name": "actors_org_agent_name_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"agent_name\"" + ], + "where": null + }, + { + "kind": "index", + "table": "actors", + "name": "actors_org_type_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"type\"" + ], + "where": null + }, + { + "kind": "index", + "table": "actors", + "name": "actors_org_user_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"user_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "agent_feedback", + "name": "agent_feedback_kind_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"kind\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "agent_feedback", + "name": "agent_feedback_org_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_delivery_events", + "name": "alert_delivery_events_claim_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"status\"", + "\"claim_expires_at\"", + "\"scheduled_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_delivery_events", + "name": "alert_delivery_events_delivery_attempt_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"delivery_key\"", + "\"attempt_number\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_delivery_events", + "name": "alert_delivery_events_due_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"status\"", + "\"scheduled_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_delivery_events", + "name": "alert_delivery_events_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_delivery_events", + "name": "alert_delivery_events_org_incident_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"incident_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_destinations", + "name": "alert_destinations_org_enabled_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"enabled\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_destinations", + "name": "alert_destinations_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_destinations", + "name": "alert_destinations_org_name_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"name\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_escalation_runs", + "name": "alert_escalation_runs_live_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"status\"", + "\"next_step_at\"" + ], + "where": "\"status\" in ('active', 'acknowledged')" + }, + { + "kind": "index", + "table": "alert_escalation_runs", + "name": "alert_escalation_runs_live_incident_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"incident_id\"" + ], + "where": "\"status\" IN ('active', 'acknowledged')" + }, + { + "kind": "index", + "table": "alert_escalation_runs", + "name": "alert_escalation_runs_org_incident_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"incident_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_incident_events", + "name": "alert_incident_events_incident_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"incident_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_incidents", + "name": "alert_incidents_incident_key_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"incident_key\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_incidents", + "name": "alert_incidents_open_group_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"rule_id\"", + "\"group_key\"" + ], + "where": "\"status\" = 'open'" + }, + { + "kind": "index", + "table": "alert_incidents", + "name": "alert_incidents_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_incidents", + "name": "alert_incidents_org_issue_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"error_issue_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_incidents", + "name": "alert_incidents_org_rule_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"rule_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_incidents", + "name": "alert_incidents_org_status_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"status\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_linear_issues", + "name": "alert_linear_issues_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_linear_issues", + "name": "alert_linear_issues_thread_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"destination_id\"", + "\"thread_key\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_maintenance_windows", + "name": "alert_maintenance_windows_enabled_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"enabled\"", + "\"id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_maintenance_windows", + "name": "alert_maintenance_windows_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_member_notifications", + "name": "alert_member_notifications_dedupe_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"dedupe_key\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_member_notifications", + "name": "alert_member_notifications_due_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"status\"", + "\"scheduled_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_member_notifications", + "name": "alert_member_notifications_org_incident_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"incident_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_rule_claims", + "name": "alert_rule_claims_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_rule_states", + "name": "alert_rule_states_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_rules", + "name": "alert_rules_org_enabled_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"enabled\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_rules", + "name": "alert_rules_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_rules", + "name": "alert_rules_org_name_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"name\"" + ], + "where": null + }, + { + "kind": "index", + "table": "alert_silences", + "name": "alert_silences_maintenance_occurrence_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"maintenance_window_id\"", + "\"starts_at\"" + ], + "where": "\"maintenance_window_id\" IS NOT NULL" + }, + { + "kind": "index", + "table": "alert_silences", + "name": "alert_silences_org_ends_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"ends_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "anomaly_detector_states", + "name": "anomaly_detector_states_evaluated_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"last_evaluated_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "anomaly_detector_states", + "name": "anomaly_detector_states_open_incident_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"open_incident_id\"" + ], + "where": "\"open_incident_id\" is not null" + }, + { + "kind": "index", + "table": "anomaly_incidents", + "name": "anomaly_incidents_open_detector_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"detector_key\"" + ], + "where": "\"status\" = 'open'" + }, + { + "kind": "index", + "table": "anomaly_incidents", + "name": "anomaly_incidents_org_detector_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"detector_key\"" + ], + "where": null + }, + { + "kind": "index", + "table": "anomaly_incidents", + "name": "anomaly_incidents_org_issue_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"error_issue_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "anomaly_incidents", + "name": "anomaly_incidents_org_status_triggered_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"status\"", + "\"last_triggered_at\"", + "\"id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "anomaly_incidents", + "name": "anomaly_incidents_org_triggered_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"last_triggered_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "api_keys", + "name": "api_keys_key_hash_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"key_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "api_keys", + "name": "api_keys_org_id_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "aws_connections", + "name": "aws_connections_org_account_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"account_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "aws_connections", + "name": "aws_connections_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "aws_connections", + "name": "aws_connections_stream_secret_hash_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"stream_secret_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cancellation_reviews", + "name": "cancellation_reviews_subscription_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"plan_id\"", + "\"subscription_started_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "chat_identities", + "name": "chat_identities_org_connector_external_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"connector\"", + "\"external_user_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "chat_identities", + "name": "chat_identities_org_connector_user_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"connector\"", + "\"user_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "chat_identities", + "name": "chat_identities_org_user_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"user_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "chat_workspaces", + "name": "chat_workspaces_connector_external_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"connector\"", + "\"external_workspace_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "chat_workspaces", + "name": "chat_workspaces_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cli_device_authorizations", + "name": "cli_device_authorizations_expires_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"expires_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cli_device_authorizations", + "name": "cli_device_authorizations_user_code_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"user_code_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cloudflare_analytics_state", + "name": "cf_analytics_state_org_account_dataset_zone_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"account_id\"", + "\"dataset\"", + "\"zone_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cloudflare_analytics_state", + "name": "cf_analytics_state_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cloudflare_hyperdrive_configs", + "name": "cloudflare_hyperdrive_configs_org_config_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"config_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cloudflare_hyperdrive_configs", + "name": "cloudflare_hyperdrive_configs_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cloudflare_logpush_connectors", + "name": "cloudflare_logpush_connectors_org_enabled_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"enabled\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cloudflare_logpush_connectors", + "name": "cloudflare_logpush_connectors_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cloudflare_logpush_connectors", + "name": "cloudflare_logpush_connectors_secret_hash_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"secret_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cloudflare_logpush_connectors", + "name": "cloudflare_logpush_connectors_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cost_connections", + "name": "cost_connections_org_provider_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"provider\"" + ], + "where": null + }, + { + "kind": "index", + "table": "cost_sources", + "name": "cost_sources_org_provider_ref_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"provider\"", + "\"connection_ref\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dashboard_shares", + "name": "dashboard_shares_id_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dashboard_shares", + "name": "dashboard_shares_live_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"dashboard_id\"", + "coalesce(widget_id, '')" + ], + "where": "revoked_at is null" + }, + { + "kind": "index", + "table": "dashboard_shares", + "name": "dashboard_shares_org_dashboard_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"dashboard_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dashboard_shares", + "name": "dashboard_shares_token_hash_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"token_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dashboard_versions", + "name": "dashboard_versions_org_dashboard_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"dashboard_id\"", + "\"version_number\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dashboard_versions", + "name": "dashboard_versions_org_dashboard_version_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"dashboard_id\"", + "\"version_number\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dashboards", + "name": "dashboards_org_name_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"name\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dashboards", + "name": "dashboards_org_updated_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"updated_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dependency_findings", + "name": "dependency_findings_key_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"lockfile_path\"", + "\"ecosystem\"", + "\"package_name\"", + "\"advisory_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dependency_findings", + "name": "dependency_findings_org_status_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"status\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dependency_findings", + "name": "dependency_findings_org_updated_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"updated_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dependency_scan_matches", + "name": "dependency_scan_matches_org_scan_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"scan_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dependency_scans", + "name": "dependency_scans_org_started_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"started_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dependency_scans", + "name": "dependency_scans_repo_commit_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"commit_sha\"" + ], + "where": null + }, + { + "kind": "index", + "table": "dependency_scans", + "name": "dependency_scans_repo_started_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"started_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "device_credentials", + "name": "device_credentials_jkt_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"jkt\"" + ], + "where": null + }, + { + "kind": "index", + "table": "device_credentials", + "name": "device_credentials_live_installation_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"installation_id\"" + ], + "where": "\"revoked_at\" IS NULL" + }, + { + "kind": "index", + "table": "device_credentials", + "name": "device_credentials_user_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"user_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "device_proof_replays", + "name": "device_proof_replays_expires_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"expires_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "digest_subscriptions", + "name": "digest_subscriptions_org_enabled_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"enabled\"" + ], + "where": null + }, + { + "kind": "index", + "table": "digest_subscriptions", + "name": "digest_subscriptions_org_user_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"user_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_fingerprint_candidates", + "name": "error_fingerprint_candidates_last_seen_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"last_seen_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_incidents", + "name": "error_incidents_org_issue_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"issue_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_incidents", + "name": "error_incidents_org_status_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"status\"", + "\"last_triggered_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_events", + "name": "error_issue_events_actor_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"actor_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_events", + "name": "error_issue_events_issue_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"issue_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_events", + "name": "error_issue_events_type_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"type\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_fingerprints", + "name": "error_issue_fingerprints_issue_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"issue_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_pull_requests", + "name": "error_issue_pull_requests_issue_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"issue_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_pull_requests", + "name": "error_issue_pull_requests_issue_pr_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"issue_id\"", + "\"provider\"", + "\"repo_full_name\"", + "\"number\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_pull_requests", + "name": "error_issue_pull_requests_repo_number_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"provider\"", + "\"repo_full_name\"", + "\"number\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_verifications", + "name": "error_issue_verifications_due_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"status\"", + "\"verify_after\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_verifications", + "name": "error_issue_verifications_issue_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"issue_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issue_verifications", + "name": "error_issue_verifications_open_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"issue_id\"" + ], + "where": "\"status\" in ('waiting', 'running')" + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_lease_expiry_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"lease_expires_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_org_archived_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"archived_at\"" + ], + "where": "\"archived_at\" is not null" + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_org_assignee_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"assigned_actor_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_org_fp_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"fingerprint_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_org_fp_version_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"fingerprint_version\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_org_kind_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"kind\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_org_live_seen_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"last_seen_at\"", + "\"id\"" + ], + "where": "\"archived_at\" is null" + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_org_merged_into_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"merged_into_issue_id\"" + ], + "where": "\"merged_into_issue_id\" is not null" + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_org_severity_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"severity\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_issues", + "name": "error_issues_org_workflow_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"workflow_state\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_notification_deliveries", + "name": "error_notification_deliveries_due_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"status\"", + "\"scheduled_at\"", + "\"claim_expires_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_notification_deliveries", + "name": "error_notification_deliveries_key_destination_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"delivery_key\"", + "\"destination_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_notification_deliveries", + "name": "error_notification_deliveries_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "error_tick_states", + "name": "error_tick_states_claim_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"claim_expires_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "escalation_chains", + "name": "escalation_chains_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "external_data_source_catalog_entries", + "name": "external_data_source_catalog_entries_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "external_data_sources", + "name": "external_data_sources_org_name_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"name\"" + ], + "where": null + }, + { + "kind": "index", + "table": "gcp_connectors", + "name": "gcp_connectors_org_scope_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"scope_type\"", + "\"scope_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "gcp_connectors", + "name": "gcp_connectors_secret_hash_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"secret_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "gcp_connectors", + "name": "gcp_connectors_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "investigations", + "name": "investigations_incident_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"incident_kind\"", + "\"incident_id\"" + ], + "where": "\"incident_id\" is not null" + }, + { + "kind": "index", + "table": "investigations", + "name": "investigations_org_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "investigations", + "name": "investigations_org_issue_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"issue_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "investigations", + "name": "investigations_org_status_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"status\"" + ], + "where": null + }, + { + "kind": "index", + "table": "issue_escalations", + "name": "issue_escalations_dedupe_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"dedupe_key\"" + ], + "where": null + }, + { + "kind": "index", + "table": "issue_escalations", + "name": "issue_escalations_due_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"status\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "issue_escalations", + "name": "issue_escalations_org_issue_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"issue_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "live_activities", + "name": "live_activities_device_incident_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"device_id\"", + "\"incident_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "live_activities", + "name": "live_activities_incident_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"incident_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "mcp_oauth_authorizations", + "name": "mcp_oauth_authorizations_code_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"authorization_code_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "mcp_oauth_authorizations", + "name": "mcp_oauth_authorizations_expires_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"expires_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "mcp_oauth_refresh_tokens", + "name": "mcp_oauth_refresh_tokens_expires_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"expires_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "mcp_oauth_refresh_tokens", + "name": "mcp_oauth_refresh_tokens_family_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"family_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "mcp_oauth_refresh_tokens", + "name": "mcp_oauth_refresh_tokens_hash_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"token_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "mobile_devices", + "name": "mobile_devices_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "mobile_devices", + "name": "mobile_devices_org_platform_token_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"platform\"", + "\"token\"" + ], + "where": null + }, + { + "kind": "index", + "table": "mobile_devices", + "name": "mobile_devices_user_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"user_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "oauth_auth_states", + "name": "oauth_auth_states_expires_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"expires_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "oauth_connections", + "name": "oauth_connections_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "oauth_connections", + "name": "oauth_connections_org_provider_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"provider\"" + ], + "where": null + }, + { + "kind": "index", + "table": "oauth_connections", + "name": "oauth_connections_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "oncall_overrides", + "name": "oncall_overrides_org_schedule_ends_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"schedule_id\"", + "\"ends_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "oncall_schedules", + "name": "oncall_schedules_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "openrouter_cost_connections", + "name": "openrouter_cost_connections_org_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_billing_links", + "name": "org_billing_links_billing_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"billing_org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_directory_groups", + "name": "org_directory_groups_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_ingest_attribute_mappings", + "name": "org_ingest_attribute_mappings_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_ingest_keys", + "name": "org_ingest_keys_private_key_hash_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"private_key_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_ingest_keys", + "name": "org_ingest_keys_public_key_hash_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"public_key_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_ingest_keys", + "name": "org_ingest_keys_public_key_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"public_key\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_ingest_rule_stats", + "name": "org_ingest_rule_stats_org_bucket_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"bucket\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_ingest_rules", + "name": "org_ingest_rules_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_recommendation_issues", + "name": "org_recommendation_issues_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_recommendation_issues", + "name": "org_recommendation_issues_org_key_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"recommendation_key\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_sso_connections", + "name": "org_sso_connections_connection_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"clerk_connection_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "org_sso_connections", + "name": "org_sso_connections_directory_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"clerk_directory_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_connections", + "name": "planetscale_connections_org_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_connections", + "name": "planetscale_connections_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_databases", + "name": "planetscale_databases_org_db_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"database_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_databases", + "name": "planetscale_databases_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_events", + "name": "planetscale_events_dedupe_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"database_name\"", + "\"event_type\"", + "\"external_id\"", + "\"occurred_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_events", + "name": "planetscale_events_org_db_time_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"database_name\"", + "\"occurred_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_events", + "name": "planetscale_events_org_time_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"occurred_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_issue_receipts", + "name": "planetscale_issue_receipts_processed_at_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"processed_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_poll_state", + "name": "planetscale_poll_state_org_dataset_db_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"dataset\"", + "\"database_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "planetscale_poll_state", + "name": "planetscale_poll_state_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_review_edits", + "name": "pr_review_edits_reply_seq_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"reply_id\"", + "\"seq\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_review_finding_embeddings", + "name": "pr_review_finding_embeddings_org_model_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"model\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_review_findings", + "name": "pr_review_findings_org_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_review_findings", + "name": "pr_review_findings_pr_handle_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"number\"", + "\"handle\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_review_merge_steps", + "name": "pr_review_merge_steps_org_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_review_merge_steps", + "name": "pr_review_merge_steps_pr_key_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"number\"", + "\"key\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_review_replies", + "name": "pr_review_replies_org_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_review_replies", + "name": "pr_review_replies_repo_comment_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"comment_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_reviews", + "name": "pr_reviews_org_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_reviews", + "name": "pr_reviews_post_merge_due_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"post_merge_after\"" + ], + "where": "\"post_merge_status\" = 'waiting'" + }, + { + "kind": "index", + "table": "pr_reviews", + "name": "pr_reviews_repo_number_head_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"number\"", + "\"head_sha\"" + ], + "where": null + }, + { + "kind": "index", + "table": "pr_reviews", + "name": "pr_reviews_repo_number_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"number\"" + ], + "where": null + }, + { + "kind": "index", + "table": "railway_connections", + "name": "railway_connections_org_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "railway_connections", + "name": "railway_connections_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "railway_environments", + "name": "railway_environments_connection_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"connection_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "railway_environments", + "name": "railway_environments_org_env_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"environment_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "saved_views", + "name": "saved_views_org_surface_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"surface\"", + "\"visibility\"" + ], + "where": null + }, + { + "kind": "index", + "table": "saved_views", + "name": "saved_views_owner_surface_name_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"owner_user_id\"", + "\"surface\"", + "\"name\"" + ], + "where": null + }, + { + "kind": "index", + "table": "scrape_target_checks", + "name": "scrape_target_checks_target_checked_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"target_id\"", + "\"checked_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "scrape_targets", + "name": "scrape_targets_org_enabled_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"enabled\"" + ], + "where": null + }, + { + "kind": "index", + "table": "scrape_targets", + "name": "scrape_targets_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "scrape_targets", + "name": "scrape_targets_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "search_console_sites", + "name": "search_console_sites_connection_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"oauth_connection_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "search_console_sites", + "name": "search_console_sites_org_site_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"site_url\"" + ], + "where": null + }, + { + "kind": "index", + "table": "security_audit_events", + "name": "security_audit_events_run_at_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"run_id\"", + "\"at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "security_audit_findings", + "name": "security_audit_findings_org_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "security_audit_findings", + "name": "security_audit_findings_target_fingerprint_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"target_id\"", + "\"fingerprint\"" + ], + "where": null + }, + { + "kind": "index", + "table": "security_audit_org_reservations", + "name": "security_audit_org_reservations_org_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "security_audit_runs", + "name": "security_audit_runs_one_running_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"target_id\"" + ], + "where": "\"finished_at\" IS NULL" + }, + { + "kind": "index", + "table": "security_audit_runs", + "name": "security_audit_runs_org_started_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"started_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "security_audit_runs", + "name": "security_audit_runs_target_started_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"target_id\"", + "\"started_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "security_audit_targets", + "name": "security_audit_targets_org_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "security_audit_targets", + "name": "security_audit_targets_org_repo_branch_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"repository\"", + "\"branch\"" + ], + "where": null + }, + { + "kind": "index", + "table": "slos", + "name": "slos_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "slos", + "name": "slos_org_name_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"name\"" + ], + "where": null + }, + { + "kind": "index", + "table": "sources", + "name": "sources_key_hash_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"key_hash\"" + ], + "where": null + }, + { + "kind": "index", + "table": "sources", + "name": "sources_org_default_kind_unique", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": "\"kind\" = 'default'" + }, + { + "kind": "index", + "table": "sources", + "name": "sources_org_id_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_cleanups", + "name": "status_page_cleanups_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_components", + "name": "status_page_components_monitor_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"monitor_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_components", + "name": "status_page_components_page_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"page_id\"", + "\"position\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_custom_domains", + "name": "status_page_custom_domains_checked_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"last_checked_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_custom_domains", + "name": "status_page_custom_domains_hostname_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"hostname\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_custom_domains", + "name": "status_page_custom_domains_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_incident_components", + "name": "status_page_incident_components_component_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"component_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_incident_updates", + "name": "status_page_incident_updates_incident_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"incident_id\"", + "\"created_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_incident_updates", + "name": "status_page_incident_updates_overlay_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"overlay_entry_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_incidents", + "name": "status_page_incidents_alert_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"alert_incident_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_page_incidents", + "name": "status_page_incidents_open_maintenance_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"scheduled_start\"" + ], + "where": "\"kind\" = 'maintenance' and \"resolved_at\" is null" + }, + { + "kind": "index", + "table": "status_page_incidents", + "name": "status_page_incidents_page_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"page_id\"", + "\"started_at\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_pages", + "name": "status_pages_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_pages", + "name": "status_pages_slug_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"slug\"" + ], + "where": null + }, + { + "kind": "index", + "table": "status_pages", + "name": "status_pages_unpublished_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"revision\"", + "\"published_revision\"" + ], + "where": "revision > published_revision" + }, + { + "kind": "index", + "table": "supabase_connections", + "name": "supabase_connections_org_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "supabase_connections", + "name": "supabase_connections_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "supabase_project_insights", + "name": "supabase_project_insights_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "supabase_projects", + "name": "supabase_projects_connection_ref_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"connection_id\"", + "\"project_ref\"" + ], + "where": null + }, + { + "kind": "index", + "table": "supabase_projects", + "name": "supabase_projects_log_drain_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"log_drain_source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "supabase_projects", + "name": "supabase_projects_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "uptime_monitor_daily", + "name": "uptime_monitor_daily_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "uptime_monitor_states", + "name": "uptime_monitor_states_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "uptime_monitors", + "name": "uptime_monitors_enabled_kind_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"enabled\"", + "\"kind\"" + ], + "where": null + }, + { + "kind": "index", + "table": "uptime_monitors", + "name": "uptime_monitors_heartbeat_token_unq", + "unique": true, + "method": "btree", + "columns": [ + "\"heartbeat_token\"" + ], + "where": null + }, + { + "kind": "index", + "table": "uptime_monitors", + "name": "uptime_monitors_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_commits", + "name": "vcs_commits_org_sha_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"sha\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_commits", + "name": "vcs_commits_repo_sha_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"sha\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_installations", + "name": "vcs_installations_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_installations", + "name": "vcs_installations_provider_external_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"provider\"", + "\"external_installation_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_installations", + "name": "vcs_installations_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_repositories", + "name": "vcs_repositories_installation_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"installation_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_repositories", + "name": "vcs_repositories_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_repositories", + "name": "vcs_repositories_org_repo_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"provider\"", + "\"external_repo_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_repository_branches", + "name": "vcs_repository_branches_org_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vcs_repository_branches", + "name": "vcs_repository_branches_repo_name_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"repository_id\"", + "\"name\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vercel_connections", + "name": "vercel_connections_org_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vercel_connections", + "name": "vercel_connections_source_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"source_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vercel_deployments", + "name": "vercel_deployments_org_deployment_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"deployment_id\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vercel_deployments", + "name": "vercel_deployments_org_project_created_idx", + "unique": false, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"project_id\"", + "\"created_at_vercel\"" + ], + "where": null + }, + { + "kind": "index", + "table": "vercel_projects", + "name": "vercel_projects_org_project_idx", + "unique": true, + "method": "btree", + "columns": [ + "\"org_id\"", + "\"project_id\"" + ], + "where": null + }, + { + "kind": "foreign_key", + "table": "alert_escalation_runs", + "name": "alert_escalation_runs_incident_id_alert_incidents_id_fk", + "columns": [ + "incident_id" + ], + "foreignTable": "alert_incidents", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "alert_incident_events", + "name": "alert_incident_events_incident_id_alert_incidents_id_fk", + "columns": [ + "incident_id" + ], + "foreignTable": "alert_incidents", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "alert_linear_issues", + "name": "alert_linear_issues_destination_id_alert_destinations_id_fk", + "columns": [ + "destination_id" + ], + "foreignTable": "alert_destinations", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "alert_member_notifications", + "name": "alert_member_notifications_incident_id_alert_incidents_id_fk", + "columns": [ + "incident_id" + ], + "foreignTable": "alert_incidents", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "aws_connections", + "name": "aws_connections_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "cloudflare_logpush_connectors", + "name": "cloudflare_logpush_connectors_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "SET NULL", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "dashboard_shares", + "name": "dashboard_shares_dashboard_fk", + "columns": [ + "org_id", + "dashboard_id" + ], + "foreignTable": "dashboards", + "foreignColumns": [ + "org_id", + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "external_data_source_catalog_entries", + "name": "external_data_source_catalog_entries_x60VonL2VphD_fk", + "columns": [ + "source_id" + ], + "foreignTable": "external_data_sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "gcp_connectors", + "name": "gcp_connectors_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "gcp_resources", + "name": "gcp_resources_connector_id_gcp_connectors_id_fk", + "columns": [ + "connector_id" + ], + "foreignTable": "gcp_connectors", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "oauth_connections", + "name": "oauth_connections_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "oncall_overrides", + "name": "oncall_overrides_schedule_id_oncall_schedules_id_fk", + "columns": [ + "schedule_id" + ], + "foreignTable": "oncall_schedules", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "planetscale_connections", + "name": "planetscale_connections_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "railway_connections", + "name": "railway_connections_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "scrape_target_checks", + "name": "scrape_target_checks_target_id_scrape_targets_id_fk", + "columns": [ + "target_id" + ], + "foreignTable": "scrape_targets", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "scrape_targets", + "name": "scrape_targets_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "search_console_sites", + "name": "search_console_sites_jBAHYyW36dnu_fk", + "columns": [ + "oauth_connection_id" + ], + "foreignTable": "oauth_connections", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "status_page_components", + "name": "status_page_components_monitor_id_uptime_monitors_id_fk", + "columns": [ + "monitor_id" + ], + "foreignTable": "uptime_monitors", + "foreignColumns": [ + "id" + ], + "onDelete": "SET NULL", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "status_page_components", + "name": "status_page_components_page_id_status_pages_id_fk", + "columns": [ + "page_id" + ], + "foreignTable": "status_pages", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "status_page_custom_domains", + "name": "status_page_custom_domains_page_id_status_pages_id_fk", + "columns": [ + "page_id" + ], + "foreignTable": "status_pages", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "status_page_incident_components", + "name": "status_page_incident_components_Bnqlt6wwKJty_fk", + "columns": [ + "component_id" + ], + "foreignTable": "status_page_components", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "status_page_incident_components", + "name": "status_page_incident_components_tBn6mEz4FenY_fk", + "columns": [ + "incident_id" + ], + "foreignTable": "status_page_incidents", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "status_page_incident_updates", + "name": "status_page_incident_updates_3LDDUAhznHPM_fk", + "columns": [ + "incident_id" + ], + "foreignTable": "status_page_incidents", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "status_page_incidents", + "name": "status_page_incidents_page_id_status_pages_id_fk", + "columns": [ + "page_id" + ], + "foreignTable": "status_pages", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "supabase_connections", + "name": "supabase_connections_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "supabase_project_insights", + "name": "supabase_project_insights_project_id_supabase_projects_id_fk", + "columns": [ + "project_id" + ], + "foreignTable": "supabase_projects", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "supabase_projects", + "name": "supabase_projects_connection_id_supabase_connections_id_fk", + "columns": [ + "connection_id" + ], + "foreignTable": "supabase_connections", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "supabase_projects", + "name": "supabase_projects_log_drain_source_id_sources_id_fk", + "columns": [ + "log_drain_source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "SET NULL", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "uptime_monitor_daily", + "name": "uptime_monitor_daily_monitor_id_uptime_monitors_id_fk", + "columns": [ + "monitor_id" + ], + "foreignTable": "uptime_monitors", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "uptime_monitor_states", + "name": "uptime_monitor_states_monitor_id_uptime_monitors_id_fk", + "columns": [ + "monitor_id" + ], + "foreignTable": "uptime_monitors", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "vcs_installations", + "name": "vcs_installations_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + }, + { + "kind": "foreign_key", + "table": "vercel_connections", + "name": "vercel_connections_source_id_sources_id_fk", + "columns": [ + "source_id" + ], + "foreignTable": "sources", + "foreignColumns": [ + "id" + ], + "onDelete": "CASCADE", + "onUpdate": "NO ACTION" + } + ] +} diff --git a/packages/db/src/tables/enterprise-sso.ts b/packages/db/src/tables/enterprise-sso.ts new file mode 100644 index 0000000000..316d25d8eb --- /dev/null +++ b/packages/db/src/tables/enterprise-sso.ts @@ -0,0 +1,76 @@ +import * as PG from "@maple-dev/effect-orm/postgres" +import { OrgId, UserId } from "@maple/primitives" +import { Schema } from "effect" + +export const SsoDomainStatus = Schema.Literals(["pending", "verified"]) +export type SsoDomainStatus = typeof SsoDomainStatus.Type + +/** + * A domain an org claims for enterprise SSO. Maple issues the TXT challenge and checks DNS itself, + * then marks the Clerk organization domain ownership-verified; only verified domains reach a connection. + */ +export const OrgSsoDomains = PG.table("org_sso_domains", { + columns: { + orgId: PG.column(PG.brand(PG.text, OrgId), { name: "org_id" }), + /** Lower-cased, no trailing dot. */ + domain: PG.text, + /** Published at `_maple-challenge.`; public by design, so stored as is. */ + challenge: PG.text, + status: PG.brand(PG.text, SsoDomainStatus), + /** The Clerk organization domain, created once ownership is proven. */ + clerkDomainId: PG.column(PG.nullable(PG.text), { name: "clerk_domain_id" }), + verifiedAt: PG.column(PG.nullable(PG.timestamptzMillis), { name: "verified_at" }), + createdAt: PG.column(PG.timestamptzMillis, { name: "created_at" }), + createdBy: PG.column(PG.brand(PG.text, UserId), { name: "created_by" }), + }, + primaryKey: ["orgId", "domain"], + tenantColumn: "orgId", +}) + +export type OrgSsoDomainRow = PG.SelectRowOf + +/** + * The org's one enterprise connection and its SCIM directory, both held in Clerk. The ids live here + * so a directory webhook finds its org, and only in the org's home region. + */ +export const OrgSsoConnections = PG.table("org_sso_connections", { + columns: { + orgId: PG.column(PG.brand(PG.text, OrgId), { name: "org_id" }), + clerkConnectionId: PG.column(PG.text, { name: "clerk_connection_id" }), + /** Null until SCIM provisioning is set up. The SCIM key itself is never stored. */ + clerkDirectoryId: PG.column(PG.nullable(PG.text), { name: "clerk_directory_id" }), + createdAt: PG.column(PG.timestamptzMillis, { name: "created_at" }), + createdBy: PG.column(PG.brand(PG.text, UserId), { name: "created_by" }), + updatedAt: PG.column(PG.timestamptzMillis, { name: "updated_at" }), + }, + primaryKey: ["orgId"], + indexes: [ + PG.uniqueIndex("org_sso_connections_connection_unq", ["clerkConnectionId"]), + PG.uniqueIndex("org_sso_connections_directory_unq", ["clerkDirectoryId"]), + ], + tenantColumn: "orgId", +}) + +export type OrgSsoConnectionRow = PG.SelectRowOf + +/** + * Groups the IdP pushed over SCIM, from Clerk's `directoryGroup.*` webhooks: Clerk has no endpoint + * that lists them, and the role mapping picker needs them. + */ +export const OrgDirectoryGroups = PG.table("org_directory_groups", { + columns: { + orgId: PG.column(PG.brand(PG.text, OrgId), { name: "org_id" }), + directoryId: PG.column(PG.text, { name: "directory_id" }), + /** The group id the directory assigned. */ + groupId: PG.column(PG.text, { name: "group_id" }), + displayName: PG.column(PG.text, { name: "display_name" }), + updatedAt: PG.column(PG.timestamptzMillis, { name: "updated_at" }), + /** Set by `directoryGroup.deleted`; kept so a late, older event cannot revive the group. */ + deletedAt: PG.column(PG.nullable(PG.timestamptzMillis), { name: "deleted_at" }), + }, + primaryKey: ["directoryId", "groupId"], + indexes: [PG.index("org_directory_groups_org_idx", ["orgId"])], + tenantColumn: "orgId", +}) + +export type OrgDirectoryGroupRow = PG.SelectRowOf diff --git a/packages/db/src/tables/index.ts b/packages/db/src/tables/index.ts index 7074c57a08..6e841a130c 100644 --- a/packages/db/src/tables/index.ts +++ b/packages/db/src/tables/index.ts @@ -76,6 +76,7 @@ import { import { CostConnections } from "./cost-connections" import { OpenRouterCostConnections } from "./openrouter-cost-connections" import { OrgOpenRouterKeys } from "./openrouter-keys" +import { OrgDirectoryGroups, OrgSsoConnections, OrgSsoDomains } from "./enterprise-sso" import { RailwayConnections, RailwayEnvironments } from "./railway" import { SavedViews } from "./saved-views" import { ScrapeTargets, ScrapeTargetChecks } from "./scrape-targets" @@ -168,6 +169,7 @@ export * from "./planetscale-inventory" export * from "./cost-connections" export * from "./openrouter-cost-connections" export * from "./openrouter-keys" +export * from "./enterprise-sso" export * from "./railway" export * from "./saved-views" export * from "./scrape-targets" @@ -260,6 +262,9 @@ export const allTables: ReadonlyArray> = [ OpenRouterCostConnections, CostConnections, OrgOpenRouterKeys, + OrgSsoDomains, + OrgSsoConnections, + OrgDirectoryGroups, OrgBillingLinks, Sources, ExternalDataSources, diff --git a/packages/domain/src/audit-actions.ts b/packages/domain/src/audit-actions.ts index 6533bfc46f..9faede52c8 100644 --- a/packages/domain/src/audit-actions.ts +++ b/packages/domain/src/audit-actions.ts @@ -78,6 +78,27 @@ export const AuditResources = { device_credential: { prefix: PublicIdPrefixes.deviceCredential, verbs: ["registered", "revoked"] }, /** Verbs mirror the issue event types: `recordEvent` audits every one it attributes. */ error_issue: { prefix: PublicIdPrefixes.errorIssue, verbs: ErrorIssueEventType.literals }, + /** Org-singleton SSO and SCIM setup; secrets (OIDC client secret, SCIM token) are never in `changes`. */ + enterprise_sso: { + verbs: [ + "domain_added", + "domain_verified", + "domain_removed", + "connection_created", + "connection_updated", + "connection_enforced", + "connection_relaxed", + "connection_deleted", + "directory_created", + "directory_key_rotated", + "directory_paused", + "directory_resumed", + "directory_deleted", + "role_mapping_updated", + "bypass_added", + "bypass_removed", + ], + }, escalation_chain: { prefix: PublicIdPrefixes.escalationChain, verbs: ["created", "updated", "deleted"], @@ -232,6 +253,7 @@ export const AuditResourceLabels = { ai_provider_key: "AI provider key", alert_destination: "Alert destination", alert_rule: "Alert rule", + enterprise_sso: "SSO and SCIM", escalation_chain: "Escalation chain", oncall_schedule: "On-call schedule", oncall_override: "On-call override", @@ -293,6 +315,22 @@ export const AuditActionLabels = { "alert_rule.created": "Created alert rule", "alert_rule.updated": "Updated alert rule", "alert_rule.deleted": "Deleted alert rule", + "enterprise_sso.domain_added": "Added SSO domain", + "enterprise_sso.domain_verified": "Verified SSO domain", + "enterprise_sso.domain_removed": "Removed SSO domain", + "enterprise_sso.connection_created": "Connected identity provider", + "enterprise_sso.connection_updated": "Updated identity provider", + "enterprise_sso.connection_enforced": "Enforced SSO", + "enterprise_sso.connection_relaxed": "Stopped enforcing SSO", + "enterprise_sso.connection_deleted": "Removed identity provider", + "enterprise_sso.directory_created": "Set up SCIM provisioning", + "enterprise_sso.directory_key_rotated": "Rotated SCIM token", + "enterprise_sso.directory_paused": "Paused SCIM provisioning", + "enterprise_sso.directory_resumed": "Resumed SCIM provisioning", + "enterprise_sso.directory_deleted": "Removed SCIM provisioning", + "enterprise_sso.role_mapping_updated": "Updated SCIM role mapping", + "enterprise_sso.bypass_added": "Added SSO bypass user", + "enterprise_sso.bypass_removed": "Removed SSO bypass user", "escalation_chain.created": "Created escalation chain", "escalation_chain.updated": "Updated escalation chain", "escalation_chain.deleted": "Deleted escalation chain", diff --git a/packages/domain/src/billing.ts b/packages/domain/src/billing.ts index 4347c886d7..52110ae332 100644 --- a/packages/domain/src/billing.ts +++ b/packages/domain/src/billing.ts @@ -49,6 +49,9 @@ export const OPENROUTER_BYOK_FEATURE_ID = "openrouter_byok" */ export const BILLING_SUB_ORGS_FEATURE_ID = "billing_sub_orgs" +/** Enterprise SSO (SAML/OIDC) and SCIM provisioning. Granted by hand on Enterprise plans in Autumn. */ +export const ENTERPRISE_SSO_FEATURE_ID = "enterprise_sso" + /** AI usage in dollars: one credit is one dollar. Chat, triage, reviews and security audits draw on it. */ export const AI_CREDITS_FEATURE_ID = "ai_credits" diff --git a/packages/domain/src/generated/anticipated-error-identifiers.ts b/packages/domain/src/generated/anticipated-error-identifiers.ts index c2203c6b71..ee288286ce 100644 --- a/packages/domain/src/generated/anticipated-error-identifiers.ts +++ b/packages/domain/src/generated/anticipated-error-identifiers.ts @@ -22,6 +22,11 @@ export const ANTICIPATED_ERROR_IDENTIFIER_LIST: ReadonlyArray = [ "@maple/http/dependency-scan/DependencyFindingNotFoundError", "@maple/http/dependency-scan/DependencyScanForbiddenError", "@maple/http/dependency-scan/DependencyScanRepositoryNotFoundError", + "@maple/http/enterprise-sso/EnterpriseSsoConflictError", + "@maple/http/enterprise-sso/EnterpriseSsoForbiddenError", + "@maple/http/enterprise-sso/EnterpriseSsoInvalidError", + "@maple/http/enterprise-sso/EnterpriseSsoNotEntitledError", + "@maple/http/enterprise-sso/EnterpriseSsoNotFoundError", "@maple/http/errors/ActorNotFoundError", "@maple/http/errors/AlertDestinationInUseError", "@maple/http/errors/AlertDestinationNotFoundError", diff --git a/packages/domain/src/http/enterprise-sso.ts b/packages/domain/src/http/enterprise-sso.ts new file mode 100644 index 0000000000..4e7d804801 --- /dev/null +++ b/packages/domain/src/http/enterprise-sso.ts @@ -0,0 +1,357 @@ +import { HttpApiEndpoint, HttpApiGroup } from "effect/http-api" +import { Schema, String as Str } from "effect" +import { IsoDateTimeString, UserId } from "@maple/primitives" +import { SessionAuthorization } from "./current-tenant" +import { HttpTaggedError } from "./error-policy" + +/** Lower-cased hostname with at least one dot, no wildcard and no trailing dot. */ +export const SsoDomainName = Schema.String.check( + Schema.isMaxLength(253), + Schema.isPattern(/^(?=.{1,253}$)(?!-)[a-z0-9-]{1,63}(?`. */ +export const SSO_CHALLENGE_RECORD_PREFIX = "_maple-challenge" + +export const SsoProtocol = Schema.Literals(["saml", "oidc"]) +export type SsoProtocol = typeof SsoProtocol.Type + +/** Clerk's organization enterprise connection providers. */ +export const SsoProvider = Schema.Literals([ + "saml_custom", + "saml_okta", + "saml_microsoft", + "saml_google", + "oidc_custom", + "oidc_github_enterprise", + "oidc_gitlab", +]) +export type SsoProvider = typeof SsoProvider.Type + +export const ssoProtocolOf = (provider: SsoProvider): SsoProtocol => + Str.startsWith("saml_")(provider) ? "saml" : "oidc" + +/** The Clerk role keys a SCIM group can grant. Engineer is included: it is a Maple role in Clerk too. */ +export const SsoMappedRole = Schema.Literals(["org:admin", "org:engineer", "org:member", "org:analyst"]) +export type SsoMappedRole = typeof SsoMappedRole.Type + +export class SsoDomainDocument extends Schema.Class("SsoDomainDocument")({ + domain: Schema.String, + status: Schema.Literals(["pending", "verified"]), + /** The TXT record to publish, e.g. `_maple-challenge.acme.com`. */ + recordName: Schema.String, + recordValue: Schema.String, + verifiedAt: Schema.NullOr(IsoDateTimeString), +}) {} + +export class SsoConnectionDocument extends Schema.Class("SsoConnectionDocument")({ + name: Schema.String, + provider: SsoProvider, + protocol: SsoProtocol, + domains: Schema.Array(Schema.String), + /** Clerk's `active`: everyone signing in with an email on these domains must use the IdP. */ + enforced: Schema.Boolean, + /** What the customer pastes into their IdP (SAML service provider values). */ + acsUrl: Schema.NullOr(Schema.String), + spEntityId: Schema.NullOr(Schema.String), + spMetadataUrl: Schema.NullOr(Schema.String), + /** The IdP side as configured; the certificate and the OIDC client secret never come back. */ + idpMetadataUrl: Schema.NullOr(Schema.String), + idpSsoUrl: Schema.NullOr(Schema.String), + idpEntityId: Schema.NullOr(Schema.String), + idpCertificateExpiresAt: Schema.NullOr(IsoDateTimeString), + oidcDiscoveryUrl: Schema.NullOr(Schema.String), + oidcClientId: Schema.NullOr(Schema.String), + createdAt: IsoDateTimeString, +}) {} + +export class ScimDirectoryDocument extends Schema.Class("ScimDirectoryDocument")({ + /** The SCIM 2.0 base URL the IdP pushes to. */ + endpointUrl: Schema.String, + enabled: Schema.Boolean, + paused: Schema.Boolean, + createdAt: IsoDateTimeString, +}) {} + +export class ScimRoleMappingDocument extends Schema.Class("ScimRoleMappingDocument")( + { + groupId: Schema.String, + groupName: Schema.NullOr(Schema.String), + role: SsoMappedRole, + }, +) {} + +export class ScimGroupDocument extends Schema.Class("ScimGroupDocument")({ + groupId: Schema.String, + displayName: Schema.String, +}) {} + +export class SsoBypassUserDocument extends Schema.Class("SsoBypassUserDocument")({ + userId: UserId, + identifier: Schema.NullOr(Schema.String), +}) {} + +/** The whole Security tab in one read. */ +export class EnterpriseSsoDocument extends Schema.Class("EnterpriseSsoDocument")({ + /** The org holds the `enterprise_sso` feature. Reads still answer when it does not. */ + entitled: Schema.Boolean, + domains: Schema.Array(SsoDomainDocument), + connection: Schema.NullOr(SsoConnectionDocument), + directory: Schema.NullOr(ScimDirectoryDocument), + /** Highest precedence first. */ + roleMappings: Schema.Array(ScimRoleMappingDocument), + groups: Schema.Array(ScimGroupDocument), + bypassUsers: Schema.Array(SsoBypassUserDocument), +}) {} + +/** A directory write that minted a SCIM token: the only response that ever carries it. */ +export class ScimTokenIssued extends Schema.Class("ScimTokenIssued")({ + document: EnterpriseSsoDocument, + token: Schema.String, +}) {} + +export class SsoAddDomainRequest extends Schema.Class("SsoAddDomainRequest")({ + domain: Schema.String.check(Schema.isMaxLength(253)), +}) {} + +const Url = Schema.String.check(Schema.isMaxLength(2048), Schema.isPattern(/^https:\/\//)) + +export class SsoSamlSettings extends Schema.Class("SsoSamlSettings")({ + /** Either a metadata URL, or the three manual fields. */ + metadataUrl: Schema.optionalKey(Url), + ssoUrl: Schema.optionalKey(Url), + entityId: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(2048))), + certificate: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(16_384))), +}) {} + +export class SsoOidcSettings extends Schema.Class("SsoOidcSettings")({ + discoveryUrl: Url, + clientId: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(512)), + /** Required on create; omitted on update keeps the stored one. */ + clientSecret: Schema.optionalKey(Schema.String.check(Schema.isMaxLength(2048))), +}) {} + +export class SsoConnectionRequest extends Schema.Class("SsoConnectionRequest")({ + name: Schema.String.check(Schema.isMinLength(1), Schema.isMaxLength(120)), + /** Ignored on update: Clerk cannot change a connection's provider. */ + provider: SsoProvider, + /** Verified domains only. */ + domains: Schema.Array(Schema.String).check(Schema.isMinLength(1), Schema.isMaxLength(20)), + saml: Schema.optionalKey(SsoSamlSettings), + oidc: Schema.optionalKey(SsoOidcSettings), +}) {} + +export class SsoEnforcementRequest extends Schema.Class("SsoEnforcementRequest")({ + enforced: Schema.Boolean, +}) {} + +export class ScimDirectoryStateRequest extends Schema.Class( + "ScimDirectoryStateRequest", +)({ + paused: Schema.Boolean, +}) {} + +export class ScimRoleMappingsRequest extends Schema.Class("ScimRoleMappingsRequest")( + { + /** Precedence is array order: the first mapping wins for a user in several groups. */ + mappings: Schema.Array( + Schema.Struct({ groupId: Schema.String.check(Schema.isMinLength(1)), role: SsoMappedRole }), + ).check(Schema.isMaxLength(100)), + }, +) {} + +export class SsoBypassRequest extends Schema.Class("SsoBypassRequest")({ + userId: UserId, +}) {} + +/** Clerk or the database could not be reached; its own text can carry internals. */ +export class EnterpriseSsoUnavailableError extends HttpTaggedError()( + "@maple/http/enterprise-sso/EnterpriseSsoUnavailableError", + { message: Schema.String, cause: Schema.optionalKey(Schema.String) }, + { + status: 503, + code: "enterprise_sso_unavailable", + title: "SSO settings are temporarily unavailable", + message: "SSO settings could not be read or saved right now. Try again in a few seconds.", + retry: "backoff", + recovery: "retry", + exposure: "redacted", + }, +) {} + +export class EnterpriseSsoForbiddenError extends HttpTaggedError()( + "@maple/http/enterprise-sso/EnterpriseSsoForbiddenError", + { message: Schema.String }, + { + status: 403, + code: "enterprise_sso_forbidden", + title: "Permission required", + retry: "never", + recovery: "request_access", + exposure: "public_message", + }, +) {} + +/** The org does not hold the `enterprise_sso` feature (the Enterprise plan). */ +export class EnterpriseSsoNotEntitledError extends HttpTaggedError()( + "@maple/http/enterprise-sso/EnterpriseSsoNotEntitledError", + { message: Schema.String }, + { + status: 402, + code: "enterprise_sso_not_entitled", + title: "Enterprise plan required", + retry: "never", + recovery: "fix_request", + exposure: "public_message", + }, +) {} + +/** A malformed value, an unverified domain, or settings the IdP or Clerk rejected. */ +export class EnterpriseSsoInvalidError extends HttpTaggedError()( + "@maple/http/enterprise-sso/EnterpriseSsoInvalidError", + { message: Schema.String }, + { + status: 400, + code: "enterprise_sso_invalid", + title: "SSO settings not accepted", + retry: "never", + recovery: "fix_request", + exposure: "public_message", + }, +) {} + +/** The thing already exists, or the domain is claimed by another organization. */ +export class EnterpriseSsoConflictError extends HttpTaggedError()( + "@maple/http/enterprise-sso/EnterpriseSsoConflictError", + { message: Schema.String }, + { + status: 409, + code: "enterprise_sso_conflict", + title: "Already set up", + retry: "never", + recovery: "fix_request", + exposure: "public_message", + }, +) {} + +export class EnterpriseSsoNotFoundError extends HttpTaggedError()( + "@maple/http/enterprise-sso/EnterpriseSsoNotFoundError", + { message: Schema.String }, + { + status: 404, + code: "enterprise_sso_not_found", + title: "Not set up", + retry: "never", + recovery: "fix_request", + exposure: "public_message", + }, +) {} + +const readErrors = [EnterpriseSsoUnavailableError] as const +const writeErrors = [ + EnterpriseSsoUnavailableError, + EnterpriseSsoForbiddenError, + EnterpriseSsoNotEntitledError, + EnterpriseSsoInvalidError, + EnterpriseSsoConflictError, + EnterpriseSsoNotFoundError, +] as const + +export class EnterpriseSsoApiGroup extends HttpApiGroup.make("enterpriseSso") + .add(HttpApiEndpoint.get("get", "/", { success: EnterpriseSsoDocument, error: readErrors })) + .add( + HttpApiEndpoint.post("addDomain", "/domains", { + payload: SsoAddDomainRequest, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.post("verifyDomain", "/domains/:domain/verify", { + params: { domain: Schema.String }, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.delete("removeDomain", "/domains/:domain", { + params: { domain: Schema.String }, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.post("createConnection", "/connection", { + payload: SsoConnectionRequest, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.patch("updateConnection", "/connection", { + payload: SsoConnectionRequest, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.put("setEnforcement", "/connection/enforcement", { + payload: SsoEnforcementRequest, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.delete("deleteConnection", "/connection", { + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.post("createDirectory", "/directory", { + success: ScimTokenIssued, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.post("rotateDirectoryToken", "/directory/token", { + success: ScimTokenIssued, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.put("setDirectoryState", "/directory/state", { + payload: ScimDirectoryStateRequest, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.delete("deleteDirectory", "/directory", { + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.put("setRoleMappings", "/directory/role-mappings", { + payload: ScimRoleMappingsRequest, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.post("addBypassUser", "/bypass", { + payload: SsoBypassRequest, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .add( + HttpApiEndpoint.delete("removeBypassUser", "/bypass/:userId", { + params: { userId: UserId }, + success: EnterpriseSsoDocument, + error: writeErrors, + }), + ) + .prefix("/internal/enterprise-sso") + .middleware(SessionAuthorization) {} diff --git a/packages/domain/src/http/index.ts b/packages/domain/src/http/index.ts index 95b6eac010..b44f6399f2 100644 --- a/packages/domain/src/http/index.ts +++ b/packages/domain/src/http/index.ts @@ -8,6 +8,7 @@ export * from "./users" export * from "./dependency-scan" export * from "./ai-triage" export * from "./openrouter-key" +export * from "./enterprise-sso" export * from "./openrouter-cost" export * from "./cost-connections" export * from "./cloudflare-cost" diff --git a/packages/domain/src/http/internal-api.ts b/packages/domain/src/http/internal-api.ts index d4b157c684..b54cdc628c 100644 --- a/packages/domain/src/http/internal-api.ts +++ b/packages/domain/src/http/internal-api.ts @@ -18,6 +18,7 @@ import { IntegrationsApiGroup } from "./integrations" import { OpenRouterCostApiGroup } from "./openrouter-cost" import { CostBudgetsApiGroup } from "./cost-budgets" import { OpenRouterKeyApiGroup } from "./openrouter-key" +import { EnterpriseSsoApiGroup } from "./enterprise-sso" import { PlanetScaleCostApiGroup } from "./planetscale-cost" import { OrgClickHouseSettingsApiGroup } from "./org-clickhouse-settings" import { @@ -70,6 +71,7 @@ export class MapleInternalApi extends HttpApi.make("MapleInternalApi") .add(IntegrationsApiGroup) .add(McpInternalApiGroup) .add(OpenRouterKeyApiGroup) + .add(EnterpriseSsoApiGroup) .add(OpenRouterCostApiGroup) .add(CloudflareCostApiGroup) .add(AnthropicCostApiGroup) diff --git a/packages/domain/src/policy/permissions.ts b/packages/domain/src/policy/permissions.ts index 716cf4b641..21025a74ab 100644 --- a/packages/domain/src/policy/permissions.ts +++ b/packages/domain/src/policy/permissions.ts @@ -49,6 +49,7 @@ export const permissions = { "security_audit:run": { min: "admin", action: "configure and run code security audits" }, "audit_log:read": { min: "admin", action: "read the audit log" }, "llm_keys:manage": { min: "admin", action: "manage the organization's model provider keys" }, + "sso:manage": { min: "admin", action: "manage single sign-on and SCIM provisioning" }, "mcp_connections:view_all": { min: "admin", action: "see every member's MCP connections" }, } as const satisfies Record