Files
outline/plugins/linear/server/api/linear.ts
T
Tom MoorandClaude Opus 5.5 50a7e61d83 chore: Upgrade @linear/sdk to 97.0.0 (#13907)
* chore: Upgrade @linear/sdk to 97.0.0

The SDK is now ESM-only, so the client is loaded via dynamic import to
match other ESM-only server dependencies. Nullable fields are now typed
as null, so the workspace logoUrl is normalised.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B2bXhKp3SJU1EJjv4uoue7

* chore: Require Node 20.19 or newer for native require of ESM packages

---------

Co-authored-by: Claude <noreply@anthropic.com>
2026-10-02 09:46:00 -04:00

121 lines
3.8 KiB
TypeScript

import Router from "koa-router";
import { toError } from "@shared/utils/error";
import { IntegrationService, IntegrationType } from "@shared/types";
import { ValidationError } from "@server/errors";
import Logger from "@server/logging/Logger";
import apexAuthRedirect from "@server/middlewares/apexAuthRedirect";
import auth from "@server/middlewares/authentication";
import { transaction } from "@server/middlewares/transaction";
import validate from "@server/middlewares/validate";
import { IntegrationAuthentication, Integration } from "@server/models";
import type { APIContext } from "@server/types";
import { verifyOAuthStateNonce } from "@server/utils/oauth";
import { Linear } from "../linear";
import UploadIntegrationLogoTask from "@server/queues/tasks/UploadIntegrationLogoTask";
import * as T from "./schema";
import {
LinearOAuthNonceCookie,
LinearUtils,
} from "plugins/linear/shared/LinearUtils";
import { addSeconds } from "date-fns";
const router = new Router();
router.get(
"linear.callback",
auth({
optional: true,
}),
validate(T.LinearCallbackSchema),
apexAuthRedirect<T.LinearCallbackReq>({
getTeamId: (ctx) => LinearUtils.parseState(ctx.input.query.state)?.teamId,
getRedirectPath: (ctx, team) =>
LinearUtils.callbackUrl({
baseUrl: team.url,
params: ctx.request.querystring,
}),
getErrorPath: () => LinearUtils.errorUrl("unauthenticated"),
}),
transaction(),
async (ctx: APIContext<T.LinearCallbackReq>) => {
const { code, error, state } = ctx.input.query;
const { user } = ctx.state.auth;
const { transaction } = ctx.state;
// Check error after any sub-domain redirection. Otherwise, the user will be redirected to the root domain.
if (error) {
ctx.redirect(LinearUtils.errorUrl(error));
return;
}
const parsedState = LinearUtils.parseState(state);
if (!parsedState) {
throw ValidationError("Invalid state");
}
verifyOAuthStateNonce(ctx, LinearOAuthNonceCookie, parsedState.nonce);
try {
// validation middleware ensures that code is non-null at this point.
const oauth = await Linear.oauthAccess(code!);
const workspace = await Linear.getInstalledWorkspace(oauth.access_token);
const authentication = await IntegrationAuthentication.create(
{
service: IntegrationService.Linear,
userId: user.id,
teamId: user.teamId,
token: oauth.access_token,
refreshToken: oauth.refresh_token,
expiresAt: oauth.expires_in
? addSeconds(Date.now(), oauth.expires_in)
: undefined,
scopes: oauth.scope.split(" "),
},
{ transaction }
);
const integration = await Integration.create<
Integration<IntegrationType.Embed>
>(
{
service: IntegrationService.Linear,
type: IntegrationType.Embed,
userId: user.id,
teamId: user.teamId,
authenticationId: authentication.id,
settings: {
linear: {
workspace: {
id: workspace.id,
name: workspace.name,
key: workspace.urlKey,
logoUrl: workspace.logoUrl ?? undefined,
},
},
},
},
{ transaction }
);
transaction.afterCommit(async () => {
if (workspace.logoUrl) {
await new UploadIntegrationLogoTask().schedule({
integrationId: integration.id,
logoUrl: workspace.logoUrl,
});
}
});
ctx.redirect(LinearUtils.successUrl());
} catch (err) {
Logger.error(
"Encountered error during Linear OAuth callback",
toError(err)
);
ctx.redirect(LinearUtils.errorUrl("unknown"));
}
}
);
export default router;