Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.
TypeScript accessibilityalternativecloudflarecloudflare-workersdesignfreefrontendopen-sourceradix-uireactremixweb-developmentwebflowwebsite-builderwebsite-developmentwebsiteswebstudio
import { TRPCError } from "@trpc/server";
import { type AppContext } from "@webstudio-is/trpc-interface/index.server";
import env from "~/env/env.server";
import { authenticator } from "~/services/auth.server";
import { trpcSharedClient } from "~/services/trpc.server";
import { entryApi } from "./entri/entri-api.server";
import { defaultPlanFeatures } from "@webstudio-is/plans";
import {
getPlanInfo,
getAuthorizationOwnerId,
} from "@webstudio-is/plans/index.server";
import { staticEnv } from "~/env/env.static.server";
import { createClient } from "@webstudio-is/postgrest/index.server";
import { builderAuthenticator } from "~/services/builder-auth.server";
import { readLoginSessionBloomFilter } from "~/services/session.server";
import type { BloomFilter } from "~/services/bloom-filter.server";
import { isBuilder, isCanvas } from "./router-utils";
import { parseBuilderUrl } from "@webstudio-is/protocol";
import {
apiClient,
apiClientHeader,
apiClientContractVersionHeader,
apiClientVersionHeader,
} from "@webstudio-is/trpc-interface/api-compatibility";
export class InvalidAuthTokenError extends TRPCError {
constructor() {
super({
code: "UNAUTHORIZED",
message: "The authorization token is invalid or no longer available",
cause: { webstudioCode: "INVALID_AUTH_TOKEN" },
});
}
}
export const extractAuthFromRequest = async (request: Request) => {
if (isCanvas(request)) {
throw new Error("Canvas requests can't have authorization context");
}
const url = new URL(request.url);
const authToken =
url.searchParams.get("authToken") ??
request.headers.get("x-auth-token") ??
undefined;
const isServiceCall = isServiceAuthorization(
request.headers.get("Authorization")
);
// Explicit credentials always win. In particular, an invalid supplied token
// must fail during context creation instead of falling back to a potentially
// more privileged browser session.
const sessionData =
authToken === undefined && isServiceCall === false
? isBuilder(request)
? await builderAuthenticator.isAuthenticated(request)
: await authenticator.isAuthenticated(request)
: undefined;
return {
authToken,
isServiceCall,
sessionData,
};
};
export const isServiceAuthorization = (authorizationHeader: string | null) => {
return (
authorizationHeader != null &&
env.TRPC_SERVER_API_TOKEN !== undefined &&
env.TRPC_SERVER_API_TOKEN.length > 0 &&
authorizationHeader === env.TRPC_SERVER_API_TOKEN
);
};
const createTokenAuthorizationContext = async (
authToken: string,
postgrest: AppContext["postgrest"]
) => {
const projectOwnerIdByToken = await postgrest.client
.from("AuthorizationToken")
.select("project:Project(id, userId)")
.eq("token", authToken)
.maybeSingle();
if (projectOwnerIdByToken.error) {
throw new Error("Failed to verify authorization token");
}
if (projectOwnerIdByToken.data === null) {
throw new InvalidAuthTokenError();
}
const ownerId = projectOwnerIdByToken.data.project?.userId ?? null;
if (ownerId === null) {
throw new InvalidAuthTokenError();
}
return {
type: "token" as const,
authToken,
ownerId,
};
};
const createAuthorizationContext = async (
request: Request,
postgrest: AppContext["postgrest"]
): Promise<AppContext["authorization"]> => {
const { authToken, isServiceCall, sessionData } =
await extractAuthFromRequest(request);
if (isServiceCall) {
return {
type: "service",
isServiceCall: true,
};
}
if (authToken != null) {
return await createTokenAuthorizationContext(authToken, postgrest);
}
if (sessionData?.userId != null) {
const userId = sessionData.userId;
let loginBloomFilter: BloomFilter | undefined = undefined;
let isLoggedInToBuilder = async (projectId: string) => {
if (loginBloomFilter === undefined) {
loginBloomFilter = await readLoginSessionBloomFilter(request);
}
return loginBloomFilter.has(projectId);
};
if (isBuilder(request)) {
isLoggedInToBuilder = async (projectId: string) => {
const parsedUrl = parseBuilderUrl(request.url);
return parsedUrl.projectId === projectId;
};
}
return {
type: "user",
userId,
sessionCreatedAt: sessionData.createdAt,
isLoggedInToBuilder,
};
}
return { type: "anonymous" };
};
const createDomainContext = () => {
const context: AppContext["domain"] = {
domainTrpc: trpcSharedClient.domain,
};
return context;
};
const getRequestOrigin = (urlStr: string) => {
const url = new URL(urlStr);
return url.origin;
};
const createDeploymentContext = (builderOrigin: string) => {
const context: AppContext["deployment"] = {
deploymentTrpc: trpcSharedClient.deployment,
env: {
BUILDER_ORIGIN: getRequestOrigin(builderOrigin),
GITHUB_REF_NAME: staticEnv.GITHUB_REF_NAME ?? "undefined",
GITHUB_SHA: staticEnv.GITHUB_SHA ?? undefined,
PUBLISHER_HOST: env.PUBLISHER_HOST,
},
};
return context;
};
const createEntriContext = () => {
return {
entryApi,
};
};
const createTrpcCache = () => {
const proceduresMaxAge = new Map<string, number>();
const setMaxAge = (path: string, value: number) => {
proceduresMaxAge.set(
path,
Math.min(proceduresMaxAge.get(path) ?? Number.MAX_SAFE_INTEGER, value)
);
};
const getMaxAge = (path: string) => proceduresMaxAge.get(path);
return {
setMaxAge,
getMaxAge,
};
};
const createApiClientContext = (request: Request): AppContext["apiClient"] => {
const client = apiClient.safeParse(request.headers.get(apiClientHeader));
if (client.success === false) {
return {
type: "unknown",
version: undefined,
contractVersion: undefined,
};
}
return {
type: client.data,
version: request.headers.get(apiClientVersionHeader) ?? undefined,
contractVersion:
request.headers.get(apiClientContractVersionHeader) ?? undefined,
};
};
export const createPostgrestContext = () => {
return { client: createClient(env.POSTGREST_URL, env.POSTGREST_API_KEY) };
};
/**
* argument buildEnv==="prod" only if we are loading project with production build
*/
export const createContext = async (request: Request): Promise<AppContext> => {
const postgrest = createPostgrestContext();
const authorization = await createAuthorizationContext(request, postgrest);
const resolvePlanInfo = async (auth: AppContext["authorization"]) => {
const ownerId = getAuthorizationOwnerId(auth);
if (ownerId === undefined) {
return {
planFeatures: defaultPlanFeatures,
purchases: [] as AppContext["purchases"],
};
}
return (
(await getPlanInfo([ownerId], { postgrest })).get(ownerId) ?? {
planFeatures: defaultPlanFeatures,
purchases: [] as AppContext["purchases"],
}
);
};
const domain = createDomainContext();
const deployment = createDeploymentContext(getRequestOrigin(request.url));
const entri = createEntriContext();
const { planFeatures, purchases } = await resolvePlanInfo(authorization);
const trpcCache = createTrpcCache();
const apiClient = createApiClientContext(request);
const getOwnerPlanFeatures = async (userId: string) => {
const results = await getPlanInfo([userId], { postgrest });
return results.get(userId)?.planFeatures ?? defaultPlanFeatures;
};
const createTokenContext = async (authToken: string) => {
const authorization = await createTokenAuthorizationContext(
authToken,
postgrest
);
const { planFeatures, purchases } = await resolvePlanInfo(authorization);
return {
authorization,
domain,
deployment,
entri,
planFeatures,
purchases,
apiClient,
trpcCache,
postgrest,
createTokenContext,
getOwnerPlanFeatures,
};
};
return {
authorization,
domain,
deployment,
entri,
planFeatures,
purchases,
apiClient,
trpcCache,
postgrest,
createTokenContext,
getOwnerPlanFeatures,
};
};