@rebasepro/server 0.20.1-canary.g4d882ca → 0.21.0

package/dist/api/rest/api-generator.d.ts

@@ -141,6 +141,34 @@ export declare class RestApiGenerator {
      * it here would report a resolution failure as a validation failure.
      */
     private resolveNestedWriteCollection;
+    /**
+     * `PATCH <collection>/<id>/<relation>/<targetId>` with a `_pivot` body: set
+     * the columns that one many-to-many link carries.
+     *
+     * The membership array on the parent (`PATCH posts/1 { tags: [...] }`) sets
+     * *which* links exist; this sets what one of them holds. They are separate
+     * because the array cannot express a single-link edit without either
+     * unlinking everything it omits or re-sending the whole set — and re-sending
+     * the set to change one `role` is exactly the lost update that the
+     * membership diff exists to avoid.
+     *
+     * Validated against the junction's own properties, through the same
+     * `assertWriteRequestValid` a row's values go through: `required`, `enum`,
+     * `min`/`max`/`matches` and per-field `access.write` mean the same thing on
+     * a payload column as on a collection's, or the promise that they are
+     * "declared exactly like collection properties" is not one.
+     */
+    private updateRelationPivotFromBody;
+    /**
+     * The synthetic collection standing in for the junction a nested path's last
+     * hop reaches through, or `undefined` when that hop is not a `manyToMany`
+     * carrying `through.properties`.
+     *
+     * Built from the relation rather than by walking every collection: the same
+     * `getJunctionConfigForRelation` the schema planner and the driver use, so
+     * the shape validated here is the shape the columns were emitted from.
+     */
+    private resolveJunctionCollection;
     /**
      * Get the request-scoped driver. Throws if none is set — never falls
      * back to the unscoped `this.driver` to avoid bypassing RLS/auth.

package/dist/auth/jwt.d.ts

@@ -249,3 +249,70 @@ export declare function generateDownloadToken(path: string, expiresInSeconds?: n
  * for a *named* source is refused and the client re-fetches `/metadata`.
  */
 export declare function verifyDownloadToken(token: string): Promise<DownloadTokenPayload | null>;
+/**
+ * Sign a short-lived token that carries state across a redirect.
+ *
+ * The generalisation of the MFA-pending token: a signed blob the server hands
+ * out and expects back, where the point is that the holder cannot edit it. The
+ * OAuth authorize flow needs one to carry the authorization request across the
+ * sign-in hop — without it, the endpoint the consent page posts to would mint a
+ * code for whatever `client_id` and `redirect_uri` its caller typed, skipping
+ * every check the authorize endpoint performs.
+ *
+ * The `purpose` is not decoration. {@link verifyAccessToken} refuses any token
+ * that has one, so nothing minted here can be replayed as a session, and
+ * {@link verifyPurposeToken} refuses a token whose purpose is not the one the
+ * caller named — so a token minted for one hop cannot be spent on another.
+ */
+export declare function signPurposeToken(purpose: string, claims: Record<string, unknown>, expiresInSeconds: number): Promise<string>;
+/** Verify a token minted by {@link signPurposeToken}, for one named purpose. */
+export declare function verifyPurposeToken<T>(purpose: string, token: string): Promise<T | null>;
+/** The `purpose` that marks a token as belonging to the MCP resource. */
+export declare const MCP_ACCESS_PURPOSE = "mcp-access";
+export interface McpAccessTokenPayload {
+    purpose: typeof MCP_ACCESS_PURPOSE;
+    /** The person the token acts for. Fed straight to `withAuth()`, so RLS sees them. */
+    uid: string;
+    roles: string[];
+    /** Granted OAuth scope, space-separated. */
+    scope: string;
+    /** Which registered client holds this token — carried for audit and revocation. */
+    clientId: string;
+    /** The resource this token is bound to (RFC 8707). */
+    aud: string;
+    iss: string;
+}
+/**
+ * Mint an access token for the MCP endpoint.
+ *
+ * Deliberately **not** an ordinary session token, and the `purpose` claim is
+ * what enforces that: {@link verifyAccessToken} refuses any token carrying one,
+ * so a credential issued to a third-party MCP client — Claude, an IDE, anything
+ * that completed the OAuth flow — cannot be replayed against `/api/data`,
+ * `/api/admin` or the websocket. It buys exactly the one resource it names.
+ *
+ * That asymmetry matters more than it first looks. These tokens are handed to
+ * software the user authorized but the operator never vetted, they live in that
+ * software's storage, and they are the only credential in this system minted
+ * for a third party. Without the purpose separation, "connect Claude to your
+ * data" would silently mean "give Claude a full session".
+ *
+ * The audience is the canonical resource URI, and {@link verifyMcpAccessToken}
+ * requires the caller to say which resource it is checking for. A token minted
+ * for another Rebase project — or another path on this one — fails there.
+ *
+ * HS256 with the shared secret, like the download token: the authorization
+ * server and the resource server are the same process, so nothing outside it
+ * ever needs to verify one, and an asymmetric key here would be a second key
+ * surface bought for nobody.
+ */
+export declare function generateMcpAccessToken(payload: Omit<McpAccessTokenPayload, "purpose">, expiresInSeconds: number): Promise<string>;
+/**
+ * Verify an MCP access token **for a specific resource**.
+ *
+ * `expectedAudience` has no default. The MCP specification requires a resource
+ * server to validate that a token was issued for it specifically, and a default
+ * would be the thing that quietly turns that check off — the caller has to say
+ * what it is, every time, so a new call site cannot forget by omission.
+ */
+export declare function verifyMcpAccessToken(token: string, expectedAudience: string): Promise<McpAccessTokenPayload | null>;

package/dist/auth/rls-scope.d.ts

@@ -37,6 +37,20 @@ export declare const SERVICE_IDENTITY: {
     uid: string;
     roles: string[];
 };
+/**
+ * Can this driver run a request as a specific user?
+ *
+ * The same question `scopeDataDriver` asks internally, exported because one
+ * caller must act on the answer BEFORE it has a request to scope.
+ *
+ * `scopeDataDriver` returns the driver unscoped when the answer is no, which is
+ * the right behaviour for `/api/data` — Mongo has no row-level security and
+ * never claimed to, and the route's own checks still apply. It is the wrong
+ * behaviour for a surface whose entire promise is "this runs as you": there,
+ * an unscoped driver silently means "runs as the database owner". So the MCP
+ * surface asks this at boot and declines to mount rather than degrade.
+ */
+export declare function supportsRlsScoping(driver: DataDriver): boolean;
 /**
  * Scope a DataDriver via `withAuth()` for RLS.
  *

package/dist/{auth-DJsLXsCR.js → auth-gzoRjnuh.js}

@@ -3,14 +3,14 @@ import __rebaseProcess from "process";
 globalThis.process ??= __rebaseProcess;
 __rebaseCreateRequire(import.meta.url);
 import { i as __toESM, n as __exportAll } from "./rolldown-runtime-dW7B1o5h.js";
-import { et as ANONYMOUS_USER_ID, tt as isAnonymousUid } from "./src-DqZ9YiGA.js";
+import { P as revokeInternalTableSql, at as isAnonymousUid, it as ANONYMOUS_USER_ID } from "./src-DW1cQ_28.js";
 import "./src-Br6ARbs6.js";
 import { n as createDdlBootstrapper, o as isSQLAdmin } from "./ddl-bootstrap-CfNvxMuK.js";
-import { t as revokeInternalTableSql } from "./internal-tables-DYVcFFSv.js";
+import { t as firstSqlRow } from "./sql-rows-C6GEc2oE.js";
 import { r as logger } from "./logger-DO2PZc4i.js";
 import { n as errorHandler, t as ApiError } from "./errors-DMImyqyR.js";
-import { a as resolveListLimitParam } from "./query-parser-BQiPZrM-.js";
-import { S as sha256Hex, _ as verifyMfaPendingToken, a as generateMfaPendingToken, b as constantTimeEqual, c as getJwks, d as hasAsymmetricSigningKey, f as hashRefreshToken, g as verifyDownloadToken, h as verifyAccessToken, i as generateDownloadToken, l as getRefreshTokenExpiry, n as configureJwt, o as generateRefreshToken, p as isJwtConfigured, r as generateAccessToken, s as getAccessTokenExpiry, t as MAX_COOKIE_AGE_MS, u as getRefreshTokenTtlMs, x as randomInt$1, y as require_jsonwebtoken } from "./jwt-DATvkKB_.js";
+import { a as resolveListLimitParam } from "./query-parser-uqzkZ82i.js";
+import { C as require_jsonwebtoken, E as randomInt$1, O as sha256Hex, _ as verifyAccessToken, b as verifyMfaPendingToken, c as getAccessTokenExpiry, d as getRefreshTokenTtlMs, f as hasAsymmetricSigningKey, i as generateDownloadToken, l as getJwks, m as isJwtConfigured, n as configureJwt, o as generateMfaPendingToken, p as hashRefreshToken, r as generateAccessToken, s as generateRefreshToken, t as MAX_COOKIE_AGE_MS, u as getRefreshTokenExpiry, v as verifyDownloadToken, w as constantTimeEqual } from "./jwt-C4OW-DNq.js";
 import { n as hasAdministrativeRole, r as isAdministrativeRole, t as ADMINISTRATIVE_ROLES } from "./admin-roles-vYdp_Pil.js";
 import { c as tryCanonicalStorageKey, i as canonicalStorageId } from "./keys-Qfc4XieN.js";
 import { createHash, randomBytes, randomInt } from "node:crypto";
@@ -241,6 +241,22 @@ function isRLSScopedDriver(driver) {
 	return "withAuth" in driver && typeof driver.withAuth === "function";
 }
 /**
+* Can this driver run a request as a specific user?
+*
+* The same question `scopeDataDriver` asks internally, exported because one
+* caller must act on the answer BEFORE it has a request to scope.
+*
+* `scopeDataDriver` returns the driver unscoped when the answer is no, which is
+* the right behaviour for `/api/data` — Mongo has no row-level security and
+* never claimed to, and the route's own checks still apply. It is the wrong
+* behaviour for a surface whose entire promise is "this runs as you": there,
+* an unscoped driver silently means "runs as the database owner". So the MCP
+* surface asks this at boot and declines to mount rather than degrade.
+*/
+function supportsRlsScoping(driver) {
+	return isRLSScopedDriver(driver);
+}
+/**
 * Scope a DataDriver via `withAuth()` for RLS.
 *
 * SECURITY: If `withAuth()` is available but fails, the error is re-thrown
@@ -3544,7 +3560,7 @@ function mountSessionRoutes(opts) {
 		clearRefreshCookie(c, config.cookieAuth);
 		const accessToken = extractBearerToken(c.req.header("authorization"));
 		if (ops.afterLogout && accessToken !== void 0) {
-			const { verifyAccessToken } = await import("./jwt-DATvkKB_.js").then((n) => n.m);
+			const { verifyAccessToken } = await import("./jwt-C4OW-DNq.js").then((n) => n.h);
 			const payload = await verifyAccessToken(accessToken);
 			if (payload) ops.afterLogout(payload.uid).catch((err) => {
 				logger.error("[AuthHooks] afterLogout error", { error: err instanceof Error ? err.message : err });
@@ -6572,11 +6588,7 @@ function createSqlRateLimitStore(driver, options = {}) {
 * being on their first request — a limiter that never limits, with no error
 * anywhere. Tolerating both costs one line.
 */
-function firstRow(result) {
-	if (Array.isArray(result)) return result[0];
-	const rows = result?.rows;
-	return Array.isArray(rows) ? rows[0] : void 0;
-}
+var firstRow = firstSqlRow;
 //#endregion
 //#region src/auth/resolve-rate-limit-store.ts
 /**
@@ -7093,6 +7105,6 @@ var auth_exports = /* @__PURE__ */ __exportAll({
 	verifyPassword: () => verifyPassword
 });
 //#endregion
-export { escapeHtml as $, MemoryRateLimitStore as A, resolveAuthHooks as B, providerVerifiedEmail as C, PUBLIC_STORAGE_PREFIX as Ct, DEFAULT_FUNCTIONS_ANONYMOUS_LIMIT as D, isBootstrapWindowOpen as E, registerDevEmailSink as F, getEmailOtpTemplate as G, validatePasswordStrength as H, SMTPEmailService as I, getPasswordResetTemplate as J, getEmailVerificationTemplate as K, createEmailService as L, clearActiveDevEmailSink as M, createDevEmailSink as N, createDataRateLimiter as O, extractLinks as P, RawHtml as Q, assertEmailLinkBases as R, pkceTokenParams as S, isOperationAllowed as St, createBuiltinAuthAdapter as T, verifyPassword as U, hashPassword as V, generateSecurePassword as W, getWelcomeEmailTemplate as X, getUserInvitationTemplate as Y, resolveEmailBranding as Z, verifyOidcIdToken as _, extractBearerToken as _t, resolveRateLimitStoreKind as a, extractUserFromToken as at, createGoogleProvider as b, scopeDataDriver as bt, createSlackProvider as c, publicObjectAuth as ct, createDiscordProvider as d, requireAuth as dt, html as et, createTwitterProvider as f, createApiKeyPreAuth as ft, tryVerifyOidcIdToken as g, validateApiKey as gt, createMicrosoftProvider as h, isApiKeyToken as ht, createApiKeyStore as i, createRequireAuth as it, activeDevEmailSink as j, defaultAuthLimiter as k, createBitbucketProvider as l, queryTokenAuth as lt, createAppleProvider as m, createStorageApiKeyGuard as mt, createCustomAuthAdapter as n, createAdapterAuthMiddleware as nt, createSqlRateLimitStore as o, fileTokenAuth as ot, createFacebookProvider as p, createFunctionApiKeyGuard as pt, getMagicLinkTemplate as q, createApiKeyRoutes as r, createAuthMiddleware as rt, createSpotifyProvider as s, optionalAuth as st, auth_exports as t, raw as tt, createGitLabProvider as u, requireAdmin as ut, createGitHubProvider as v, safeCompare as vt, createJwksRoutes as w, isPublicStoragePath as wt, oauthCodeFlowSchema as x, httpMethodToOperation as xt, createLinkedinProvider as y, SERVICE_IDENTITY as yt, resolveEmailLinkBase as z };
+export { RawHtml as $, defaultAuthLimiter as A, resolveEmailLinkBase as B, providerVerifiedEmail as C, httpMethodToOperation as Ct, DEFAULT_FUNCTIONS_ANONYMOUS_LIMIT as D, isBootstrapWindowOpen as E, isPublicStoragePath as Et, extractLinks as F, generateSecurePassword as G, hashPassword as H, registerDevEmailSink as I, getMagicLinkTemplate as J, getEmailOtpTemplate as K, SMTPEmailService as L, activeDevEmailSink as M, clearActiveDevEmailSink as N, createDataRateLimiter as O, createDevEmailSink as P, resolveEmailBranding as Q, createEmailService as R, pkceTokenParams as S, supportsRlsScoping as St, createBuiltinAuthAdapter as T, PUBLIC_STORAGE_PREFIX as Tt, validatePasswordStrength as U, resolveAuthHooks as V, verifyPassword as W, getUserInvitationTemplate as X, getPasswordResetTemplate as Y, getWelcomeEmailTemplate as Z, verifyOidcIdToken as _, validateApiKey as _t, resolveRateLimitStoreKind as a, createRequireAuth as at, createGoogleProvider as b, SERVICE_IDENTITY as bt, createSlackProvider as c, optionalAuth as ct, createDiscordProvider as d, requireAdmin as dt, escapeHtml as et, createTwitterProvider as f, requireAuth as ft, tryVerifyOidcIdToken as g, isApiKeyToken as gt, createMicrosoftProvider as h, createStorageApiKeyGuard as ht, createApiKeyStore as i, createAuthMiddleware as it, MemoryRateLimitStore as j, createRateLimiter as k, createBitbucketProvider as l, publicObjectAuth as lt, createAppleProvider as m, createFunctionApiKeyGuard as mt, createCustomAuthAdapter as n, raw as nt, createSqlRateLimitStore as o, extractUserFromToken as ot, createFacebookProvider as p, createApiKeyPreAuth as pt, getEmailVerificationTemplate as q, createApiKeyRoutes as r, createAdapterAuthMiddleware as rt, createSpotifyProvider as s, fileTokenAuth as st, auth_exports as t, html as tt, createGitLabProvider as u, queryTokenAuth as ut, createGitHubProvider as v, extractBearerToken as vt, createJwksRoutes as w, isOperationAllowed as wt, oauthCodeFlowSchema as x, scopeDataDriver as xt, createLinkedinProvider as y, safeCompare as yt, assertEmailLinkBases as z };
 
-//# sourceMappingURL=auth-DJsLXsCR.js.map
+//# sourceMappingURL=auth-gzoRjnuh.js.map