The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.
TypeScript clickhousemysqlnextjsopen-sourceplanetscaleprismatailwindcsstinybirdtypescriptupstashvercel
import { after, NextResponse } from "next/server";
import "server-only";
import { generateErrorMessage } from "zod-error";
import { ZodOpenApiResponseObject } from "zod-openapi";
import * as z from "zod/v4";
import { logger } from "../axiom/server";
import { WorkspaceProps } from "../types";
import { ErrorCode, ErrorCodes } from "./error-codes";
const speakeasyErrorOverrides: Record<z.infer<typeof ErrorCode>, string> = {
bad_request: "BadRequest",
unauthorized: "Unauthorized",
forbidden: "Forbidden",
exceeded_limit: "ExceededLimit",
not_found: "NotFound",
conflict: "Conflict",
invite_pending: "InvitePending",
invite_expired: "InviteExpired",
unprocessable_entity: "UnprocessableEntity",
rate_limit_exceeded: "RateLimitExceeded",
internal_server_error: "InternalServerError",
};
const ErrorSchema = z.object({
error: z.object({
code: ErrorCode.meta({
description: "A short code indicating the error code returned.",
example: "not_found",
}),
message: z.string().meta({
description: "A human readable error message.",
example: "The requested resource was not found.",
}),
doc_url: z.string().optional().meta({
description: "A URL to more information about the error code reported.",
example: "https://dub.co/docs/api-reference",
}),
}),
});
type ErrorResponse = z.infer<typeof ErrorSchema>;
export type ErrorCodes = z.infer<typeof ErrorCode>;
export class DubApiError extends Error {
public readonly code: z.infer<typeof ErrorCode>;
public readonly docUrl?: string;
constructor({
code,
message,
docUrl,
}: {
code: z.infer<typeof ErrorCode>;
message: string;
docUrl?: string;
}) {
super(message);
this.code = code;
this.docUrl = docUrl ?? `${docErrorUrl}#${code.replace("_", "-")}`;
}
}
const docErrorUrl = "https://dub.co/docs/api-reference/errors";
export function fromZodError(error: z.ZodError): ErrorResponse {
return {
error: {
code: "unprocessable_entity",
message: generateErrorMessage(error.issues, {
maxErrors: 1,
delimiter: {
component: ": ",
},
path: {
enabled: true,
type: "objectNotation",
label: "",
},
code: {
enabled: true,
label: "",
},
message: {
enabled: true,
label: "",
},
}),
doc_url: `${docErrorUrl}#unprocessable-entity`,
},
};
}
export function handleApiError({
error,
workspace,
}: {
error: any;
workspace?: Pick<WorkspaceProps, "id">;
}): ErrorResponse & { status: number } {
console.error(error.message);
// Send error to Axiom
logger.error(error.message, {
error,
...(workspace?.id ? { workspaceId: workspace.id } : {}),
});
after(() => logger.flush());
// Zod errors
if (error instanceof z.ZodError) {
return {
...fromZodError(error),
status: ErrorCodes.unprocessable_entity,
};
}
// DubApiError errors
if (error instanceof DubApiError) {
return {
error: {
code: error.code,
message: error.message,
doc_url: error.docUrl,
},
status: ErrorCodes[error.code],
};
}
// Prisma record not found error
if (error.code === "P2025") {
return {
error: {
code: "not_found",
message:
error?.meta?.cause ||
error.message ||
"The requested resource was not found.",
doc_url: `${docErrorUrl}#not-found`,
},
status: 404,
};
}
// Fallback
// Unhandled errors are not user-facing, so we don't expose the actual error
return {
error: {
code: "internal_server_error",
message:
"An internal server error occurred. Please contact our support if the problem persists.",
doc_url: `${docErrorUrl}#internal-server-error`,
},
status: 500,
};
}
export function handleAndReturnErrorResponse(err: unknown, headers?: Headers) {
const { error, status } = handleApiError({
error: err,
});
return NextResponse.json<ErrorResponse>({ error }, { headers, status });
}
export const errorSchemaFactory = (
code: z.infer<typeof ErrorCode>,
description: string,
): ZodOpenApiResponseObject => {
return {
description,
content: {
"application/json": {
schema: {
"x-speakeasy-name-override": speakeasyErrorOverrides[code],
type: "object",
properties: {
error: {
type: "object",
properties: {
code: {
type: "string",
enum: [code],
description:
"A short code indicating the error code returned.",
example: code,
},
message: {
"x-speakeasy-error-message": true,
type: "string",
description:
"A human readable explanation of what went wrong.",
example: "The requested resource was not found.",
},
doc_url: {
type: "string",
description:
"A link to our documentation with more details about this error code",
example: `${docErrorUrl}#${code.replace("_", "-")}`,
},
},
required: ["code", "message"],
},
},
required: ["error"],
},
},
},
};
};